ctx-core 5.16.1 → 5.17.0

package/all/batch_queue/index.test.ts

@@ -6,23 +6,23 @@ test('batch_queue_(1).add|enqueue 1 at a time & run 1 at a time', async ()=>{
 	const batch_queue = batch_queue_(1)
 	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
 	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
-	const ret0_a:any[] = [null, null, null]
-	const ret1_a:any[] = [null, null, null]
+	const ret0_a:unknown[] = [null, null, null]
+	const ret1_a:unknown[] = [null, null, null]
 	batch_queue.add(fn_a[0])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[0] = ret0
-		ret1_p.then(ret0=>ret1_a[0] = ret0)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[0] = ret0
+			ret1_p.then(ret0=>ret1_a[0] = ret0)
+		})
 	batch_queue.add(fn_a[1])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[1] = ret0
-		ret1_p.then(ret1=>ret1_a[1] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[1] = ret0
+			ret1_p.then(ret1=>ret1_a[1] = ret1)
+		})
 	batch_queue.add(fn_a[2])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[2] = ret0
-		ret1_p.then(ret1=>ret1_a[2] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[2] = ret0
+			ret1_p.then(ret1=>ret1_a[2] = ret1)
+		})
 	equal(ret0_a, [null, null, null])
 	equal(ret1_a, [null, null, null])
 	await new Promise(res=>queueMicrotask(()=>res(null)))
@@ -55,23 +55,23 @@ test('batch_queue_(1, 2).add|enqueue 2 at a time & run 1 at a time', async ()=>{
 	const batch_queue = batch_queue_(1, 2)
 	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
 	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
-	const ret0_a:any[] = [null, null, null]
-	const ret1_a:any[] = [null, null, null]
+	const ret0_a:unknown[] = [null, null, null]
+	const ret1_a:unknown[] = [null, null, null]
 	batch_queue.add(fn_a[0])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[0] = ret0
-		ret1_p.then(ret0=>ret1_a[0] = ret0)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[0] = ret0
+			ret1_p.then(ret0=>ret1_a[0] = ret0)
+		})
 	batch_queue.add(fn_a[1])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[1] = ret0
-		ret1_p.then(ret1=>ret1_a[1] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[1] = ret0
+			ret1_p.then(ret1=>ret1_a[1] = ret1)
+		})
 	batch_queue.add(fn_a[2])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[2] = ret0
-		ret1_p.then(ret1=>ret1_a[2] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[2] = ret0
+			ret1_p.then(ret1=>ret1_a[2] = ret1)
+		})
 	equal(ret0_a, [null, null, null])
 	equal(ret1_a, [null, null, null])
 	await new Promise(res=>queueMicrotask(()=>res(null)))
@@ -104,23 +104,23 @@ test('batch_queue_(2).add|enqueue 2 at a time & run 2 at a time', async ()=>{
 	const batch_queue = batch_queue_(2)
 	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
 	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
-	const ret0_a:any[] = [null, null, null]
-	const ret1_a:any[] = [null, null, null]
+	const ret0_a:unknown[] = [null, null, null]
+	const ret1_a:unknown[] = [null, null, null]
 	batch_queue.add(fn_a[0])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[0] = ret0
-		ret1_p.then(ret0=>ret1_a[0] = ret0)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[0] = ret0
+			ret1_p.then(ret0=>ret1_a[0] = ret0)
+		})
 	batch_queue.add(fn_a[1])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[1] = ret0
-		ret1_p.then(ret1=>ret1_a[1] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[1] = ret0
+			ret1_p.then(ret1=>ret1_a[1] = ret1)
+		})
 	batch_queue.add(fn_a[2])
-	.then(([ret0, ret1_p])=>{
-		ret0_a[2] = ret0
-		ret1_p.then(ret1=>ret1_a[2] = ret1)
-	})
+		.then(([ret0, ret1_p])=>{
+			ret0_a[2] = ret0
+			ret1_p.then(ret1=>ret1_a[2] = ret1)
+		})
 	equal(ret0_a, [null, null, null])
 	equal(ret1_a, [null, null, null])
 	await new Promise(res=>queueMicrotask(()=>res(null)))

package/all/be_lock_memosig_triple/index.test.ts

@@ -3,7 +3,7 @@ import { equal } from 'uvu/assert'
 import { be_, type Ctx_wide_T } from '../be_/index.js'
 import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
-import { memosig_, type sig_T } from '../rmemo/index.js'
+import { memo_, memosig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
 import { be_lock_memosig_triple_ } from './index.js'
 test('be_lock_memosig_triple_', ()=>{
@@ -42,7 +42,7 @@ test('be_lock_memosig_triple_', ()=>{
 })
 test('be_lock_memosig_triple_|+id|+ns', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
 		base_,
@@ -52,8 +52,8 @@ test('be_lock_memosig_triple_|+id|+ns', ()=>{
 		{ ns: 'test_ns' })
 	const [
 		,
-		subscriber_dep_,
-		subscriber_dep__set
+		add_dep_,
+		add_dep__set
 	] = be_sig_triple_(()=>1,
 		{ ns: 'test_ns' })
 	const [
@@ -68,38 +68,38 @@ test('be_lock_memosig_triple_|+id|+ns', ()=>{
 			return base_(ctx) + 1
 		},
 		{ id: 'foobar', ns: 'test_ns' }
-	).add((ctx, foobar$)=>{
-		subscriber_count++
-		subscriber_dep__set(ctx, subscriber_count + foobar$())
-	})
-	equal(subscriber_count, 0)
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 2)
-	equal(subscriber_dep_(ctx), 3)
+	equal(add_dep_(ctx), 3)
 	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
 	equal(foobar$_(ctx)._, 5)
 	equal(foobar_(ctx), 5)
 	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
-	equal(subscriber_count, 2)
-	equal(subscriber_dep_(ctx), 7)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
 	base__set(ctx, 2)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
 	equal(foobar$_(ctx)._, 5)
 	equal(foobar_(ctx), 5)
-	equal(subscriber_count, 2)
+	equal(add_count, 2)
 	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
-	equal(subscriber_dep_(ctx), 7)
+	equal(add_dep_(ctx), 7)
 })
 test('be_lock_memosig_triple_|+be', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
 		base_,
@@ -118,19 +118,20 @@ test('be_lock_memosig_triple_|+be', ()=>{
 			const foobar$ =
 				memosig_(
 					()=>base_(ctx) + 1
-				).add(foobar$=>{
-					foobar$()
-					subscriber_count++
-				}) as custom_sig_T
+				).add(foobar$=>
+					memo_(()=>{
+						foobar$()
+						add_count++
+					})) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', ns: 'test_ns' }))
-	equal(subscriber_count, 0)
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	foobar__set(ctx, 5)
@@ -138,7 +139,7 @@ test('be_lock_memosig_triple_|+be', ()=>{
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
 	equal(foobar$_(ctx)._, 5)
 	equal(foobar_(ctx), 5)
-	equal(subscriber_count, 2)
+	equal(add_count, 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 5)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	base__set(ns_ctx__new(ctx__new(), ctx), 2)
@@ -148,7 +149,7 @@ test('be_lock_memosig_triple_|+be', ()=>{
 	equal(foobar_(ctx), 3)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
-	equal(subscriber_count, 3)
+	equal(add_count, 3)
 })
 test.run()
 type custom_sig_T = sig_T<number>&{

package/all/be_memo_pair/index.test.ts

@@ -3,8 +3,7 @@ import { equal } from 'uvu/assert'
 import { be_, type Ctx_wide_T } from '../be_/index.js'
 import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
-import type { memo_T, sig_T } from '../rmemo/index.js'
-import { memo_ } from '../rmemo/index.js'
+import { memo_, type memo_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
 import { be_memo_pair_ } from './index.js'
 test('be_memo_pair_', ()=>{
@@ -16,7 +15,7 @@ test('be_memo_pair_', ()=>{
 	const [
 		foobar$_,
 		foobar_,
-	] = be_memo_pair_<number, '', sig_T<number>&{ count:number }>((
+	] = be_memo_pair_<number, '', memo_T<number>&{ count:number }>((
 		_ctx,
 		foobar$
 	)=>{
@@ -37,13 +36,13 @@ test('be_memo_pair_', ()=>{
 	equal(foobar_(ctx), 3)
 	equal(foobar$_(ctx).count, 2)
 })
-test('be_memo_pair_|+id|+ns|+oninit|+subscriber_a', ()=>{
+test('be_memo_pair_|+id|+ns|+oninit|+add', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
-		subscriber_dep_,
-		subscriber_dep__set
+		add_dep_,
+		add_dep__set
 	] = be_sig_triple_(()=>1,
 		{ ns: 'test_ns' })
 	const [
@@ -58,31 +57,31 @@ test('be_memo_pair_|+id|+ns|+oninit|+subscriber_a', ()=>{
 	] = be_memo_pair_<number, 'test_ns'>(
 		ctx=>base_(ctx) + 1,
 		{ id: 'foobar', ns: 'test_ns' }
-	).add((ctx, foobar$)=>{
+	).add((ctx, foobar$)=>memo_(()=>{
 		/* eslint-disable @typescript-eslint/no-unused-vars */
 		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 		/* eslint-enable @typescript-eslint/no-unused-vars */
-		subscriber_count++
-		subscriber_dep__set(ctx, subscriber_count + foobar$())
-	})
-	equal(subscriber_count, 0)
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 2)
-	equal(subscriber_count, 1)
-	equal(subscriber_dep_(ctx), 3)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
 	base__set(ctx, 2)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
 	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 3)
-	equal(subscriber_count, 2)
-	equal(subscriber_dep_(ctx), 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 5)
 })
-test('be_memo_pair_|subscriber|receives a memosig to set the value of the memo', ()=>{
+test('be_memo_pair_|add|receives a memosig to set the value of the memo', ()=>{
 	const ctx = ctx__new()
 	const [
 		,
@@ -97,9 +96,9 @@ test('be_memo_pair_|subscriber|receives a memosig to set the value of the memo',
 		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
 		/* eslint-enable @typescript-eslint/no-unused-vars */
 		return 1
-	}).add((ctx, foobar$)=>{
+	}).add((ctx, foobar$)=>memo_(()=>{
 		foobar$._ = base_(ctx) + 1
-	})
+	}))
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 	base__set(ctx, 2)
@@ -108,7 +107,7 @@ test('be_memo_pair_|subscriber|receives a memosig to set the value of the memo',
 })
 test('be_memo_pair_|be', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
 		base_,
@@ -125,7 +124,7 @@ test('be_memo_pair_|be', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ = memo_(
 				()=>base_(ctx) + 1
-			).add(()=>subscriber_count++) as custom_memo_T
+			).add(()=>add_count++) as custom_memo_T
 			equal(_ctx.s.test_ns, ctx.s.test_ns)
 			foobar$.custom = 'custom-val'
 			return foobar$
@@ -133,14 +132,14 @@ test('be_memo_pair_|be', ()=>{
 			id: 'foobar',
 			ns: 'test_ns',
 		}))
-	equal(subscriber_count, 0)
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	base__set(ctx, 2)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
@@ -148,7 +147,7 @@ test('be_memo_pair_|be', ()=>{
 	equal(foobar_(ctx), 3)
 	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 })
 test.run()
-type custom_memo_T = sig_T<number>&{ custom:string }
+type custom_memo_T = memo_T<number>&{ custom:string }

package/all/be_memosig_triple/index.test.ts

@@ -3,7 +3,7 @@ import { equal } from 'uvu/assert'
 import { be_, type Ctx_wide_T } from '../be_/index.js'
 import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
-import { memosig_, type sig_T } from '../rmemo/index.js'
+import { memo_, memosig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
 import { be_memosig_triple_ } from './index.js'
 test('be_memosig_triple_', ()=>{
@@ -42,7 +42,7 @@ test('be_memosig_triple_', ()=>{
 })
 test('be_memosig_triple_|+id|+ns', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
 		base_,
@@ -52,8 +52,8 @@ test('be_memosig_triple_|+id|+ns', ()=>{
 		{ ns: 'test_ns' })
 	const [
 		,
-		subscriber_dep_,
-		subscriber_dep__set
+		add_dep_,
+		add_dep__set
 	] = be_sig_triple_(()=>1,
 		{ ns: 'test_ns' })
 	const [
@@ -68,41 +68,41 @@ test('be_memosig_triple_|+id|+ns', ()=>{
 			return base_(ctx) + 1
 		},
 		{ id: 'foobar', ns: 'test_ns' }
-	).add((ctx, foobar$)=>{
+	).add((ctx, foobar$)=>memo_(()=>{
 		/* eslint-disable @typescript-eslint/no-unused-vars */
 		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 		/* eslint-enable @typescript-eslint/no-unused-vars */
-		subscriber_count++
-		subscriber_dep__set(ctx, subscriber_count + foobar$())
-	})
-	equal(subscriber_count, 0)
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
-	equal(subscriber_dep_(ctx), 3)
+	equal(add_dep_(ctx), 3)
 	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
 	equal(foobar$_(ctx)._, 5)
 	equal(foobar_(ctx), 5)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 5)
-	equal(subscriber_count, 2)
-	equal(subscriber_dep_(ctx), 7)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
 	base__set(ctx, 2)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
-	equal(subscriber_count, 3)
+	equal(add_count, 3)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 3)
-	equal(subscriber_dep_(ctx), 6)
+	equal(add_dep_(ctx), 6)
 })
 test('be_memosig_triple_|+be', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
 		base_,
@@ -121,19 +121,20 @@ test('be_memosig_triple_|+be', ()=>{
 			const foobar$ =
 				memosig_(
 					()=>base_(ctx) + 1
-				).add(foobar$=>{
-					foobar$()
-					subscriber_count++
-				}) as custom_sig_T
+				).add(foobar$=>
+					memo_(()=>{
+						foobar$()
+						add_count++
+					})) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', ns: 'test_ns' }))
-	equal(subscriber_count, 0)
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	foobar__set(ctx, 5)
@@ -141,7 +142,7 @@ test('be_memosig_triple_|+be', ()=>{
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
 	equal(foobar$_(ctx)._, 5)
 	equal(foobar_(ctx), 5)
-	equal(subscriber_count, 2)
+	equal(add_count, 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 5)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	base__set(ns_ctx__new(ctx__new(), ctx), 2)
@@ -151,7 +152,7 @@ test('be_memosig_triple_|+be', ()=>{
 	equal(foobar_(ctx), 3)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
-	equal(subscriber_count, 3)
+	equal(add_count, 3)
 })
 test.run()
 type custom_sig_T = sig_T<number>&{

package/all/be_sig_triple/index.d.ts

@@ -26,6 +26,6 @@ export type be_sig_triple_T<
 	ctx__set_T<ctx_T, val_T>
 ]&{
 	add<add_val_T>(
-		add_def:(ctx:ctx_T, sig:_sig_T, prev_val:add_val_T|undefined)=>add_val_T
+		add_def:(ctx:ctx_T, sig:_sig_T)=>add_val_T
 	):be_sig_triple_T<val_T, ns_T, _sig_T, ctx_T>
 }

package/all/be_sig_triple/index.test.ts

@@ -2,7 +2,7 @@ import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_, type Ctx_wide_T } from '../be_/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
-import { sig_, type sig_T } from '../rmemo/index.js'
+import { memo_, sig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
 import { be_sig_triple_ } from './index.js'
 test('be_sig_triple_', ()=>{
@@ -26,11 +26,11 @@ test('be_sig_triple_', ()=>{
 })
 test('be_sig_triple_|+id|+ns', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		,
-		subscriber_dep_,
-		subscriber_dep__set
+		add_dep_,
+		add_dep__set
 	] = be_sig_triple_(()=>1,
 		{ ns: 'test_ns' })
 	const [
@@ -44,17 +44,17 @@ test('be_sig_triple_|+id|+ns', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
 		}, { id: 'foobar', ns: 'test_ns' }
-	).add((ctx, foobar$)=>{
-		subscriber_count++
-		subscriber_dep__set(ctx, subscriber_count + foobar$())
-	})
-	equal(subscriber_count, 0)
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 1)
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
-	equal(subscriber_count, 1)
-	equal(subscriber_dep_(ctx), 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 1)
 	foobar__set(ns_ctx__new(ctx__new(), ctx), 2)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
@@ -62,12 +62,12 @@ test('be_sig_triple_|+id|+ns', ()=>{
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
-	equal(subscriber_count, 2)
-	equal(subscriber_dep_(ctx), 4)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 4)
 })
 test('be_sig_triple_|+be', ()=>{
 	const ctx = ns_ctx__new('test_ns')
-	let subscriber_count = 0
+	let add_count = 0
 	const [
 		foobar$_,
 		foobar_,
@@ -80,16 +80,16 @@ test('be_sig_triple_|+be', ()=>{
 			const foobar$ =
 				sig_(
 					1
-				).add(()=>subscriber_count++) as custom_sig_T
+				).add(()=>add_count++) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$ as custom_sig_T
 		}, { id: 'foobar', ns: 'test_ns' }))
-	equal(subscriber_count, 0)
+	equal(add_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 1)
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 1)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	foobar__set(ns_ctx__new(ctx__new(), ctx), 2)
@@ -99,7 +99,7 @@ test('be_sig_triple_|+be', ()=>{
 	equal(foobar_(ctx), 2)
 	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
-	equal(subscriber_count, 1)
+	equal(add_count, 1)
 })
 test.run()
 type custom_sig_T = sig_T<number>&{

package/all/rmemo/index.d.ts

@@ -3,28 +3,36 @@ export declare function memo_<val_T>(def:memo_def_T<val_T>):memo_T<val_T>
 export declare function sig_<val_T>(init_val:val_T):sig_T<val_T>
 export declare function memosig_<val_T>(def:memo_def_T<val_T>):sig_T<val_T>
 export declare function lock_memosig_<val_T>(def:memo_def_T<val_T>):sig_T<val_T>
-export declare function rmemo__on(rmemo:rmemo_T<unknown>):void
-export declare function rmemo__off(rmemo:rmemo_T<unknown>):void
-export declare function rmemo__add(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>void
+export declare function rmemo__on<val_T>(rmemo:rmemo_T<val_T>, off_fn?:(rmemo:rmemo_T<val_T>)=>unknown):void
+export declare function rmemo__off<val_T>(rmemo:rmemo_T<val_T>):void
+export declare function rmemo__off__add<val_T>(rmemo:rmemo_T<val_T>, off_fn:(rmemo:rmemo_T<val_T>)=>unknown):void
+export declare function rmemo__add<val_T, listener_val_T>(
+	rmemo:rmemo_T<val_T>,
+	listener:(sig:sig_T<val_T>)=>listener_val_T
+):()=>void
 export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>|lock_memosig_T<val_T>
 export type circular_rmemo_T = circular_memo_T|circular_sig_T|circular_lock_memosig_T
 export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T
+	readonly a?:rmemo_a_T[]
+	readonly f?:rmemo_f_T
+	readonly s?:rmemo_r_T
+	readonly t:rmemo_r_T[]
 	readonly val:val_T
-	r?:WeakRef<()=>val_T>
-	memor:WeakRef<()=>val_T>[]
-	a?:rmemo_a_T[]
-	add<add_val_T>(add_def:(sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T):memo_T<val_T>
+	add<add_val_T>(add_def:rmemo_add_def_T<val_T, add_val_T>):memo_T<val_T>
+	memo_<_val_T>(def:memo_def_T<_val_T>):memo_T<_val_T>
 }
 export interface circular_memo_T extends memo_T<circular_memo_T> {
 }
 export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
+	readonly a?:rmemo_a_T
+	readonly f?:rmemo_f_T
+	readonly s?:rmemo_r_T
+	readonly t:rmemo_r_T[]
 	readonly val:val_T
-	r?:WeakRef<()=>val_T>
-	memor:WeakRef<()=>val_T>[]
-	a?:rmemo_a_T[]
-	add<add_val_T>(fn:(sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T):sig_T<val_T>
+	add<add_val_T>(fn:rmemo_add_def_T<val_T, add_val_T>):sig_T<val_T>
+	memo_<_val_T>(def:memo_def_T<_val_T>):memo_T<_val_T>
 }
 export interface circular_sig_T extends sig_T<circular_sig_T> {
 }
@@ -37,5 +45,11 @@ export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 	? val_T
 	: unknown
 export type memo_def_T<val_T> = (sig:sig_T<val_T>)=>val_T
-export type rmemo_a_T = [memo_T<unknown>, unknown]
-export type rmemo_add_T<val_T, SV> = (sig:sig_T<val_T>, old_val:SV|undefined)=>SV
+export type rmemo_a_T = unknown[]
+export type rmemo_add_def_T<val_T, add_val_T> = (sig:sig_T<val_T>)=>add_val_T
+export type rmemo_f_T = (()=>void)&{
+	readonly l:number
+	readonly s:rmemo_T<unknown>[]
+	readonly t:rmemo_T<unknown>[]
+}
+export type rmemo_r_T = WeakRef<rmemo_f_T>&{ readonly d?: ()=>rmemo_f_T }

package/all/rmemo/index.js

@@ -1,26 +1,31 @@
 /// <reference types="./index.d.ts" />
-/** @type {WeakRef<memo_T>} */
+/** @type {memo_T} */
 let cur_memo
-/** @type {Set<()=>unknown>} */
+/** @type {Set<(()=>unknown)&{ l:number }>} */
 let queue = new Set
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_T<unknown>[]}add_def_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {memo_T}
  * @private
  */
 export function memo_(memo_def, ...add_def_a) {
+	/** @type {memo_T} */
 	let memo = ()=>{
 		if (!('val' in memo)) {
 			memo.f()
 		}
 		if (cur_memo) {
-			if (!memo.memor.includes(cur_memo.r ||= new WeakRef(cur_memo.f))) memo.memor.push(cur_memo.r)
+			if (!memo.t.includes(
+				cur_memo.s ||= new WeakRef(cur_memo.f)
+			)) {
+				memo.t.push(cur_memo.s)
+			}
 			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
 			// memo is called by cur_memo's conditional execution...next change to memo will notify cur_memo
 			cur_memo.f.s.push(memo)
 			// prevent memo from GC while cur_memo still has a strong reference
-			if (!cur_memo.f.S.includes(memo)) cur_memo.f.S.push(memo)
+			if (!cur_memo.f.t.includes(memo)) cur_memo.f.t.push(memo)
 		}
 		return memo.val
 	}
@@ -28,7 +33,7 @@ export function memo_(memo_def, ...add_def_a) {
 		get: memo,
 		set: val=>{
 			if (memo.val !== val) {
-				memo.memor = memo.memor.filter(r=>{
+				memo.t = memo.t.filter(r=>{
 					r = r.deref()
 					if (r && r.s.includes(memo)) { // if added by cur_memo.f.s.push(memo), add to queue
 						queue.add(r)
@@ -53,16 +58,21 @@ export function memo_(memo_def, ...add_def_a) {
 			}
 		},
 	})
+	/**
+	 * @param {rmemo_add_def_T}add_def
+	 * @returns {memo_T}
+	 */
 	memo.add = add_def=>{
 		if (memo.a) {
-			let pair = [memo_(()=>pair[1] = add_def(memo, pair[1]))]
-			memo.a.push(pair)
-			pair[0]()
+			let v = add_def(memo)
+			if (v instanceof Object) memo.a.push(v)
+			if (v.memo_) v()
 		} else {
 			add_def_a.push(add_def)
 		}
 		return memo
 	}
+	memo.memo_ = memo_
 	memo.f = ()=>{
 		let prev_memo = cur_memo
 		cur_memo = memo
@@ -76,22 +86,23 @@ export function memo_(memo_def, ...add_def_a) {
 	}
 	memo.f.l = 0
 	memo.f.s = []
-	memo.f.S = []
-	memo.memor = []
+	memo.f.t = []
+	memo.t = []
 	return memo
 }
 export { memo_ as memosig_ }
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_T<unknown>[]}subscriber_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {sig_T}
  * @private
  */
-export function lock_memosig_(memo_def, ...subscriber_a) {
+export function lock_memosig_(memo_def, ...add_def_a) {
 	let lock_memosig = new Proxy(
-		/** @type {sig_T} */memo_(memo=>
-			memo.lock ? memo._ : memo_def(memo),
-		...subscriber_a),
+		/** @type {sig_T} */
+		memo_(memo=>
+			memo.lock ? memo() : memo_def(memo),
+		...add_def_a),
 		{
 			get(memo, prop) {
 				if (prop === 'add') {
@@ -114,54 +125,75 @@ export function lock_memosig_(memo_def, ...subscriber_a) {
 }
 /**
  * @param {unknown}init_val
- * @param {rmemo_add_T[]}add_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {sig_T}
  * @private
  */
-export function sig_(init_val, ...add_a) {
+export function sig_(init_val, ...add_def_a) {
 	return memo_(sig=>
 		'val' in sig
 			? sig.val
 			: init_val,
-	...add_a)
+	...add_def_a)
 }
 /**
  * Call the rmemo & enable updates from it's parents.
  * @param {rmemo_T}rmemo
+ * @param {(rmemo:rmemo_T)=>unknown}[off_fn]
+ * @returns {rmemo_T}
  */
-export function rmemo__on(rmemo) {
-	if (rmemo.r?.d) {
-		rmemo.r.deref = rmemo.r.d
+export function rmemo__on(rmemo, off_fn) {
+	if (off_fn) rmemo__off__add(rmemo, off_fn)
+	if (rmemo.s?.d) {
+		rmemo.s.deref = rmemo.s.d
 	}
 	rmemo.f()
+	return rmemo
 }
 /**
  * Disable updates from the rmemo's parents.
  * @param {rmemo_T}rmemo
+ * @returns {rmemo_T}
  */
 export function rmemo__off(rmemo) {
-	if (rmemo.r) {
-		rmemo.r.d ||= rmemo.r.deref
-		rmemo.r.deref = ()=>{
+	if (rmemo.s) {
+		rmemo.s.d ??= rmemo.s.deref
+		rmemo.s.deref = ()=>{
 		}
 	}
+	for (let a_o of rmemo.a ?? []) {
+		if (a_o.memo_) rmemo__off(a_o)
+	}
+	for (let fn of rmemo.o ?? []) {
+		fn(rmemo)
+	}
+	return rmemo
+}
+/**
+ * @param {rmemo_T}rmemo
+ * @param {(rmemo:rmemo_T)=>unknown}off_fn
+ * @returns {rmemo_T}
+ */
+export function rmemo__off__add(rmemo, off_fn) {
+	rmemo.o ??= []
+	rmemo.o.push(off_fn)
+	return rmemo
 }
 /**
  * Bind reactive add_def onto the given memo to prevent GC.
  * The add_def can autosubscribe to any rmemo.
  * Returns an "off" function which deactivates the reactive add_def & removes the GC binding from the given memo.
  * @param {rmemo_T}memo
- * @param {()=>unknown}add_def
+ * @param {rmemo_add_def_T}add_def
  * @returns {()=>void}
  */
 export function rmemo__add(memo, add_def) {
-	let pair
-	memo.add(()=>{
-		pair = memo.a[memo.a.length - 1]
-		return add_def(memo)
+	let val
+	memo.add((...arg_a)=>{
+		return val = add_def(...arg_a)
 	})
 	return ()=>{
-		rmemo__off(pair[0])
-		memo.a.splice(memo.a.indexOf(pair), 1)
+		if (val.memo_) rmemo__off(val)
+		if (val instanceof Object) memo.a.splice(memo.a.indexOf(val), 1)
 	}
 }

package/all/rmemo/index.test.ts

@@ -4,7 +4,19 @@ import { deepStrictEqual } from 'node:assert'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { sleep } from '../sleep/index.js'
-import { lock_memosig_, memo_, type memo_T, memosig_, rmemo__off, rmemo__on, rmemo__add, sig_ } from './index.js'
+import {
+	lock_memosig_,
+	memo_,
+	type memo_T,
+	memosig_,
+	rmemo__add,
+	rmemo__off,
+	rmemo__off__add,
+	rmemo__on,
+	type rmemo_T,
+	sig_,
+	type sig_T
+} from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
 	const memo = memo_(()=>{
@@ -19,7 +31,7 @@ test('memo_|static value', ()=>{
 })
 test('memo_|def function|rmemo argument', ()=>{
 	const sig = sig_('val0')
-	const memo:memo_T<string>&{ custom?:string } = memo_<string>((_rmemo$:memo_T<string>&{ custom?:string })=>
+	const memo:memo_T<string>&{ custom?:string } = memo_<string>((_rmemo$:sig_T<string>&{ custom?:string })=>
 		`${_rmemo$.custom}-${sig()}`)
 	memo.custom = 'custom_val0'
 	equal(memo(), 'custom_val0-val0')
@@ -172,17 +184,21 @@ test('sig_|undefined', ()=>{
 	equal(memo(), undefined)
 })
 test('rmemo|subscriber|has strong reference to the return value', ()=>{
-	const add_arg_aa:[memo_T<number|undefined>, number|undefined][] = []
+	const add_arg_aa:[sig_T<number|undefined>, number|undefined][] = []
+	let memo:memo_T<number>|undefined
 	const num$ = sig_<number|undefined>(
 		undefined
-	).add<number>((sig, old_val)=>{
-		add_arg_aa.push([sig, old_val])
-		return 99
-	})
+	).add(sig=>
+		memo = memo_<number>(memo=>{
+			add_arg_aa.push([sig, memo.val])
+			return 99
+		}))
 	equal(num$.a, undefined)
 	equal(add_arg_aa, [])
 	equal(num$(), undefined)
-	equal(num$.a![0][1], 99)
+	equal(num$.a![0], memo)
+	equal(memo!.val, 99)
+	equal((num$.a![0] as memo_T<number>).val, 99)
 	equal(add_arg_aa, [[num$, undefined]])
 })
 test('sig_|subscriber|notified if sig is set before read', ()=>{
@@ -190,10 +206,11 @@ test('sig_|subscriber|notified if sig is set before read', ()=>{
 	let subscriber__num:number|undefined = undefined
 	const num$ = sig_<number|undefined>(
 		undefined
-	).add(num$=>{
-		count++
-		subscriber__num = num$()
-	})
+	).add(num$=>
+		memo_(()=>{
+			count++
+			subscriber__num = num$()
+		}))
 	equal(count, 0)
 	equal(subscriber__num, undefined)
 	num$._ = 1
@@ -208,10 +225,11 @@ test('sig_|subscriber|sets sig', ()=>{
 	let count = 0
 	const num$ = sig_(
 		0
-	).add(async num$=>{
-		count++
-		num$._ = base$() + 1
-	})
+	).add(num$=>
+		memo_(()=>{
+			count++
+			num$._ = base$() + 1
+		}))
 	equal(count, 0)
 	equal(num$(), 1)
 	equal(count, 1)
@@ -227,12 +245,12 @@ test('sig_|async subsubscriber|case 1', async ()=>{
 	let count = 0
 	const user$ = sig_<{ id:string }|null>(
 		null
-	).add(async (_user$)=>{
+	).add((_user$)=>memo_(async ()=>{
 		count++
 		id$()
 		const user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
 		_user$._ = user
-	})
+	}))
 	equal(count, 0)
 	equal(user$(), null)
 	equal(count, 1)
@@ -255,13 +273,14 @@ test('sig_|async subsubscriber|case 2', async ()=>{
 	const taskArgumentsCalls:number[][] = []
 	const sum$ = sig_<null|number>(
 		null
-	).add(async sum$=>{
-		taskArgumentsCalls.push([a$(), b$()])
-		for (let i = 0; i < sleepCycles; i++) {
-			await Promise.resolve()
-		}
-		sum$._ = a$() + b$()
-	})
+	).add(sum$=>
+		memo_(async ()=>{
+			taskArgumentsCalls.push([a$(), b$()])
+			for (let i = 0; i < sleepCycles; i++) {
+				await Promise.resolve()
+			}
+			sum$._ = a$() + b$()
+		}))
 	equal(sum$(), null)
 	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
 	a$._ = 10
@@ -312,8 +331,9 @@ test('prevents diamond dependency problem 1', ()=>{
 	const d$ = memo_(()=>a$().replace('a', 'd'))
 	memo_(
 		()=>`${b$()}${c$()}${d$()}`)
-		.add(combined$=>values.push(combined$()))
-		()
+		.add(combined$=>
+			memo_(()=>values.push(combined$()))
+		)()
 	deepStrictEqual(values, ['b0c0d0'])
 	store$._ = 1
 	store$._ = 2
@@ -329,8 +349,9 @@ test('prevents diamond dependency problem 2', ()=>{
 	const e$ = memo_(()=>d$().replace('d', 'e'))
 	memo_<string>(
 		()=>[a$(), e$()].join(''))
-		.add($=>values.push($()))
-		()
+		.add($=>
+			memo_(()=>values.push($()))
+		)()
 	deepStrictEqual(values, ['a0e0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
@@ -344,8 +365,9 @@ test('prevents diamond dependency problem 3', ()=>{
 	const d$ = memo_(()=>c$().replace('c', 'd'))
 	memo_<string>(
 		()=>`${a$()}${b$()}${c$()}${d$()}`)
-		.add(combined$=>values.push(combined$()))
-		()
+		.add(combined$=>
+			memo_(()=>values.push(combined$()))
+		)()
 	deepStrictEqual(values, ['a0b0c0d0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
@@ -363,12 +385,14 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 	const g$ = memo_(()=>`g${f$()}`)
 	memo_(
 		()=>e$())
-		.add(combined1$=>values.push(combined1$()))
-		()
+		.add(combined1$=>
+			memo_(()=>values.push(combined1$()))
+		)()
 	memo_(
 		()=>[e$(), g$()].join(''))
-		.add(combined2$=>values.push(combined2$()))
-		()
+		.add(combined2$=>
+			memo_(()=>values.push(combined2$()))
+		)()
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
 	store1$._ = 1
 	store2$._ = 2
@@ -416,8 +440,9 @@ test('prevents diamond dependency problem 6', ()=>{
 	const c$ = memo_(()=>b$().replace('b', 'c'))
 	memo_(
 		()=>`${a$()}${c$()}`)
-		.add(combined$=>values.push(combined$()))
-		()
+		.add(combined$=>
+			memo_(()=>values.push(combined$()))
+		)()
 	deepStrictEqual(values, ['a0c0'])
 	store1$._ = 1
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
@@ -430,7 +455,8 @@ test('prevents dependency listeners from being out of order', ()=>{
 	const values:string[] = []
 	const b$ = memo_(
 		()=>`${a$()}b`)
-		.add(b$=>values.push(b$()))
+		.add(b$=>
+			memo_(()=>values.push(b$())))
 	equal(b$(), '0ab')
 	deepStrictEqual(values, ['0ab'])
 	equal(a$(), '0a')
@@ -443,51 +469,67 @@ test('computes initial value when argument is undefined', ()=>{
 	equal(one$(), undefined)
 	equal(two$(), false)
 })
-test('.rmemo__on + .rmemo__off', ()=>{
+test('.rmemo__on,.rmemo__off__add,.rmemo__off', ()=>{
 	const base$ = sig_(1)
 	let count = 0
+	const rmemo__off__add_arg_aa:[rmemo_T<number>][] = []
+	const rmemo__on__off_arg_aa:[rmemo_T<number>][] = []
 	const memo$ = memo_(()=>{
 		count++
 		return base$() + 10
 	})
+	rmemo__off__add(memo$, (...arg_a)=>{
+		rmemo__off__add_arg_aa.push(arg_a)
+	})
 	equal(memo$(), 11)
 	equal(count, 1)
 	base$._ = 2
 	equal(memo$(), 12)
 	equal(count, 2)
+	equal(rmemo__off__add_arg_aa, [])
 	rmemo__off(memo$)
+	equal(rmemo__off__add_arg_aa, [[memo$]])
 	base$._ = 3
 	equal(memo$(), 12)
 	equal(count, 2)
+	equal(rmemo__off__add_arg_aa, [[memo$]])
 	rmemo__on(memo$)
 	equal(memo$(), 13)
 	equal(count, 3)
+	equal(rmemo__off__add_arg_aa, [[memo$]])
 	rmemo__off(memo$)
-	rmemo__on(memo$)
+	equal(rmemo__off__add_arg_aa, [[memo$], [memo$]])
+	rmemo__on(memo$, (...arg_a)=>{
+		rmemo__on__off_arg_aa.push(arg_a)
+	})
+	equal(rmemo__off__add_arg_aa, [[memo$], [memo$]])
+	equal(rmemo__on__off_arg_aa, [])
 	equal(count, 4)
 	base$._ = 4
 	equal(memo$(), 14)
 	equal(count, 5)
+	equal(rmemo__off__add_arg_aa, [[memo$], [memo$]])
+	equal(rmemo__on__off_arg_aa, [])
+	rmemo__off(memo$)
+	equal(rmemo__off__add_arg_aa, [[memo$], [memo$], [memo$]])
+	equal(rmemo__on__off_arg_aa, [[memo$]])
 })
 test('rmemo__add', ()=>{
 	const base$ = sig_(1)
-	let count = 0
-	const subscriber_base_a:number[] = []
-	const off = rmemo__add(base$, ()=>{
-		count++
-		subscriber_base_a.push(base$())
+	const add_arg_aa_val_aaa:[[sig_T<number>], string|undefined, number][] = []
+	const off = rmemo__add<number, memo_T<string>>(base$, (...arg_a)=>{
+		return memo_(val$=>{
+			add_arg_aa_val_aaa.push([arg_a, val$.val, arg_a[0]()])
+			return 'val-' + arg_a[0]()
+		})
 	})
-	equal(subscriber_base_a, [])
-	equal(count, 0)
+	equal(add_arg_aa_val_aaa, [])
 	base$()
-	equal(subscriber_base_a, [1])
-	equal(count, 1)
+	equal(add_arg_aa_val_aaa, [[[base$], undefined, 1]])
 	base$._ = 2
-	equal(subscriber_base_a, [1, 2])
-	equal(count, 2)
+	equal(add_arg_aa_val_aaa, [[[base$], undefined, 1], [[base$], 'val-1', 2]])
 	off()
 	base$._ = 3
-	equal(subscriber_base_a, [1, 2])
-	equal(count, 2)
+	equal(add_arg_aa_val_aaa, [[[base$], undefined, 1], [[base$], 'val-1', 2]])
 })
 test.run()

package/all/rmemo__wait/index.test.ts

@@ -8,7 +8,7 @@ test('rmemo__wait', async ()=>{
 		subject$,
 		subject=>subject >= 0,
 		10_000)
-	equal(promise.m.memor, [])
+	equal(promise.m.t, [])
 	equal(subject$(), -1)
 	subject$._ = 1
 	equal(subject$(), 1)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ctx-core",
-	"version": "5.16.1",
+	"version": "5.17.0",
 	"description": "ctx-core core library",
 	"keywords": [
 		"ctx-core",
@@ -145,8 +145,8 @@
 		"@arethetypeswrong/cli": "^0.13.5",
 		"@ctx-core/preprocess": "^0.1.0",
 		"@size-limit/preset-small-lib": "^11.0.1",
-		"@types/node": "^20.10.7",
-		"@types/sinon": "^17.0.2",
+		"@types/node": "^20.11.0",
+		"@types/sinon": "^17.0.3",
 		"c8": "^9.0.0",
 		"check-dts": "^0.7.2",
 		"esbuild": "^0.19.11",
@@ -210,28 +210,28 @@
 			"import": {
 				"./rmemo": "{ memo_ }"
 			},
-			"limit": "355 B"
+			"limit": "352 B"
 		},
 		{
 			"name": "memo_ sig_",
 			"import": {
 				"./rmemo": "{ sig_, memo_ }"
 			},
-			"limit": "377 B"
+			"limit": "370 B"
 		},
 		{
 			"name": "memo_ sig_ be_ ctx_",
 			"import": {
 				"./rmemo": "{ sig_, memo_, be_, ctx_ }"
 			},
-			"limit": "478 B"
+			"limit": "471 B"
 		},
 		{
 			"name": "memo_ sig_ be_ ctx_ be_memo_pair_ be_sig_triple_",
 			"import": {
 				"./rmemo": "{ sig_, memo_, be_, ctx_, be_memo_pair_, be_sig_triple_ }"
 			},
-			"limit": "580 B"
+			"limit": "570 B"
 		},
 		{
 			"name": "uuid",
@@ -248,4 +248,4 @@
 			"limit": "116 B"
 		}
 	]
-}
+}