ctx-core 5.15.0 → 5.16.1

package/all/be_lock_memosig_triple/index.d.ts

@@ -1,5 +1,5 @@
 import type { Be, be_config_T, Ctx, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T, } from '../be_/index.js'
-import { lock_memosig_T } from '../rmemo/index.js'
+import { lock_memosig_T, sig_T } from '../rmemo/index.js'
 export declare function be_lock_memosig_triple_<
 	val_T,
 	ns_T extends string = '',
@@ -13,9 +13,7 @@ export declare function be_lock_memosig_triple_<
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
 >(
 	rmemo__new:(ctx:ctx_T, memosig:_sig_T)=>val_T,
-	...subscriber_a_THEN_config:
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[]]
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[], config:be_config_T<ns_T>]
+	config?:be_config_T<ns_T>
 ):be_lock_memosig_triple_T<val_T, ns_T, _sig_T, ctx_T>
 export type be_lock_memosig_triple_T<
 	val_T,
@@ -26,4 +24,8 @@ export type be_lock_memosig_triple_T<
 	ctx__be_T<ctx_T, _sig_T, ns_T>,
 	ctx__get_T<ctx_T, val_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
+	):be_lock_memosig_triple_T<val_T, ns_T, _sig_T, ctx_T>
+}

package/all/be_lock_memosig_triple/index.js

@@ -6,33 +6,34 @@ import { be_ } from '../be_/index.js'
 import { lock_memosig_ } from '../rmemo/index.js'
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
- * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {be_config_T}[config]
  * @returns {be_lock_memosig_triple_T}
  * @private
  */
 export function be_lock_memosig_triple_(
 	be_OR_val__new,
-	...subscriber_a_THEN_config
+	config
 ) {
-	let config =
-		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
-			? subscriber_a_THEN_config.pop()
-			: 0
+	let add_def_a = []
 	/** @type {Be<sig_T>} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				lock_memosig_(
-					memo=>be_OR_val__new(ctx, memo),
-					...subscriber_a_THEN_config.map(subscriber=>
-						sig=>subscriber(ctx, sig))),
+				add_def_a.reduce(
+					(memosig, add_def)=>memosig.add((...arg_a)=>add_def(ctx, ...arg_a)),
+					lock_memosig_(memo=>be_OR_val__new(ctx, memo))),
 			config)
-	return [
+	let be_lock_memosig_triple = [
 		be,
 		ctx=>be(ctx)(),
 		(ctx, val)=>{
 			be(ctx)._ = val
 		},
 	]
+	be_lock_memosig_triple.add = add_def=>{
+		add_def_a.push(add_def)
+		return be_lock_memosig_triple
+	}
+	return be_lock_memosig_triple
 }

package/all/be_lock_memosig_triple/index.test.ts

@@ -67,11 +67,11 @@ test('be_lock_memosig_triple_|+id|+ns', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return base_(ctx) + 1
 		},
-		(ctx, foobar$)=>{
-			subscriber_count++
-			subscriber_dep__set(ctx, subscriber_count + foobar$())
-		},
-		{ id: 'foobar', ns: 'test_ns' })
+		{ id: 'foobar', ns: 'test_ns' }
+	).add((ctx, foobar$)=>{
+		subscriber_count++
+		subscriber_dep__set(ctx, subscriber_count + foobar$())
+	})
 	equal(subscriber_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
@@ -116,11 +116,12 @@ test('be_lock_memosig_triple_|+be', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ =
-				memosig_(()=>base_(ctx) + 1,
-					foobar$=>{
-						foobar$()
-						subscriber_count++
-					}) as custom_sig_T
+				memosig_(
+					()=>base_(ctx) + 1
+				).add(foobar$=>{
+					foobar$()
+					subscriber_count++
+				}) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', ns: 'test_ns' }))

package/all/be_memo_pair/index.d.ts

@@ -13,9 +13,7 @@ export declare function be_memo_pair_<
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 >(
 	rmemo__new:(ctx:ctx_T, memo:_memo_T&{ _:val_T })=>val_T,
-	...subscriber_a_THEN_config:
-		|[...((ctx:ctx_T, memosig:sig_T<val_T>)=>unknown)[]]
-		|[...((ctx:ctx_T, memosig:sig_T<val_T>)=>unknown)[], config:be_config_T]
+	config?:be_config_T
 ):be_memo_pair_T<val_T, ns_T, _memo_T, ctx_T>
 export type be_memo_pair_T<
 	val_T,
@@ -25,4 +23,8 @@ export type be_memo_pair_T<
 > = [
 	ctx__be_T<ctx_T, _memo_T, ns_T>,
 	ctx__get_T<ctx_T, val_T>,
-]
+]&{
+	add<add_val_T>(
+		add_def:(ctx:ctx_T, sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T
+	):be_memo_pair_T<val_T, ns_T, _memo_T, ctx_T>
+}

package/all/be_memo_pair/index.js

@@ -5,32 +5,34 @@ import { be_ } from '../be_/index.js'
 import { memo_ } from '../rmemo/index.js'
 /**
  * @param {Be|be__val__new_T<unknown>}be_OR_val__new
- * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {be_config_T}[config]
  * @returns {be_memo_pair_T}
  * @private
  */
 export function be_memo_pair_(
 	be_OR_val__new,
-	...subscriber_a_THEN_config
+	config
 ) {
-	let config =
-		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
-			&& subscriber_a_THEN_config.pop()
+	let add_def_a = []
 	/** @type {Be} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				memo_(
-					memo=>be_OR_val__new(ctx, memo),
-					...subscriber_a_THEN_config.map(subscriber=>
-						memo=>subscriber(ctx, memo))),
+				add_def_a.reduce(
+					(memo, add_def)=>memo.add((...arg_a)=>add_def(ctx, ...arg_a)),
+					memo_(memo=>be_OR_val__new(ctx, memo))),
 			config)
-	return [
+	let be_memo_pair = [
 		be,
 		ctx=>be(ctx)._,
 		(ctx, val)=>{
 			be(ctx)._ = val
 		},
 	]
+	be_memo_pair.add = add_def=>{
+		add_def_a.push(add_def)
+		return be_memo_pair
+	}
+	return be_memo_pair
 }

package/all/be_memo_pair/index.test.ts

@@ -55,15 +55,16 @@ test('be_memo_pair_|+id|+ns|+oninit|+subscriber_a', ()=>{
 	const [
 		foobar$_,
 		foobar_,
-	] = be_memo_pair_<number, 'test_ns'>(ctx=>base_(ctx) + 1,
-		(ctx, foobar$)=>{
-			/* 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$())
-		},
-		{ id: 'foobar', ns: 'test_ns' })
+	] = be_memo_pair_<number, 'test_ns'>(
+		ctx=>base_(ctx) + 1,
+		{ id: 'foobar', ns: 'test_ns' }
+	).add((ctx, foobar$)=>{
+		/* 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)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
@@ -96,7 +97,7 @@ 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
-	}, (ctx, foobar$)=>{
+	}).add((ctx, foobar$)=>{
 		foobar$._ = base_(ctx) + 1
 	})
 	equal(foobar$_(ctx)._, 2)
@@ -123,9 +124,8 @@ test('be_memo_pair_|be', ()=>{
 			type test__ctx = Expect<Equal<typeof _ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ = memo_(
-				()=>base_(ctx) + 1,
-				()=>subscriber_count++
-			) as custom_memo_T
+				()=>base_(ctx) + 1
+			).add(()=>subscriber_count++) as custom_memo_T
 			equal(_ctx.s.test_ns, ctx.s.test_ns)
 			foobar$.custom = 'custom-val'
 			return foobar$

package/all/be_memosig_triple/index.d.ts

@@ -13,9 +13,7 @@ export declare function be_memosig_triple_<
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 >(
 	rmemo__new:(ctx:ctx_T, memosig:_sig_T)=>val_T,
-	...subscriber_a_THEN_config:
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[]]
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[], config:be_config_T<ns_T>]
+	config?:be_config_T<ns_T>
 ):be_memosig_triple_T<val_T, ns_T, _sig_T, ctx_T>
 export type be_memosig_triple_T<
 	val_T,
@@ -26,4 +24,8 @@ export type be_memosig_triple_T<
 	ctx__be_T<ctx_T, _sig_T, ns_T>,
 	ctx__get_T<ctx_T, val_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
+	):be_memosig_triple_T<val_T, ns_T, _sig_T, ctx_T>
+}

package/all/be_memosig_triple/index.test.ts

@@ -67,14 +67,14 @@ test('be_memosig_triple_|+id|+ns', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return base_(ctx) + 1
 		},
-		(ctx, foobar$)=>{
-			/* 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$())
-		},
-		{ id: 'foobar', ns: 'test_ns' })
+		{ id: 'foobar', ns: 'test_ns' }
+	).add((ctx, foobar$)=>{
+		/* 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)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
@@ -119,11 +119,12 @@ test('be_memosig_triple_|+be', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ =
-				memosig_(()=>base_(ctx) + 1,
-					foobar$=>{
-						foobar$()
-						subscriber_count++
-					}) as custom_sig_T
+				memosig_(
+					()=>base_(ctx) + 1
+				).add(foobar$=>{
+					foobar$()
+					subscriber_count++
+				}) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', ns: 'test_ns' }))

package/all/be_sig_triple/index.d.ts

@@ -13,17 +13,19 @@ export declare function be_sig_triple_<
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
 >(
 	val__new:(ctx:ctx_T)=>val_T,
-	...subscriber_a_THEN_config:
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[]]
-		|[...((ctx:ctx_T, sig:_sig_T)=>unknown)[], config:be_config_T<ns_T>]
+	config?:be_config_T<ns_T>
 ):be_sig_triple_T<val_T, ns_T, _sig_T, ctx_T>
 export type be_sig_triple_T<
 	val_T,
-	source extends string = '',
+	ns_T extends string = '',
 	_sig_T extends sig_T<val_T> = sig_T<val_T>,
-	ctx_T extends Ctx = Ctx_wide_T<source>
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 > = [
-	ctx__be_T<ctx_T, _sig_T, source>,
+	ctx__be_T<ctx_T, _sig_T, ns_T>,
 	ctx__get_T<ctx_T, val_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
+	):be_sig_triple_T<val_T, ns_T, _sig_T, ctx_T>
+}

package/all/be_sig_triple/index.js

@@ -5,32 +5,34 @@ import { be_ } from '../be_/index.js'
 import { sig_ } from '../rmemo/index.js'
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
- * @param {memo_subscriber_T[]|[...memo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @param {be_config_T}[config]
  * @returns {be_sig_triple_T}
  * @private
  */
 export function be_sig_triple_(
 	be_OR_val__new,
-	...subscriber_a_THEN_config
+	config
 ) {
-	let config =
-		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
-			&& subscriber_a_THEN_config.pop()
+	let add_def_a = []
 	/** @ype {Be<sig_T>} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				sig_(
-					be_OR_val__new(ctx),
-					...subscriber_a_THEN_config.map(subscriber=>
-						sig=>subscriber(ctx, sig))),
+				add_def_a.reduce(
+					(sig, add_def)=>sig.add((...arg_a)=>add_def(ctx, ...arg_a)),
+					sig_(be_OR_val__new(ctx))),
 			config)
-	return [
+	let be_sig_triple = [
 		be,
 		ctx=>be(ctx)(),
 		(ctx, val)=>{
 			be(ctx)._ = val
 		},
 	]
+	be_sig_triple.add = add_def=>{
+		add_def_a.push(add_def)
+		return be_sig_triple
+	}
+	return be_sig_triple
 }

package/all/be_sig_triple/index.test.ts

@@ -43,11 +43,11 @@ test('be_sig_triple_|+id|+ns', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
-		},
-		(ctx, foobar$)=>{
-			subscriber_count++
-			subscriber_dep__set(ctx, subscriber_count + foobar$())
-		}, { id: 'foobar', ns: 'test_ns' })
+		}, { id: 'foobar', ns: 'test_ns' }
+	).add((ctx, foobar$)=>{
+		subscriber_count++
+		subscriber_dep__set(ctx, subscriber_count + foobar$())
+	})
 	equal(subscriber_count, 0)
 	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
 	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 1)
@@ -78,7 +78,9 @@ test('be_sig_triple_|+be', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ =
-				sig_(1, ()=>subscriber_count++) as custom_sig_T
+				sig_(
+					1
+				).add(()=>subscriber_count++) as custom_sig_T
 			foobar$.custom = 'custom-val'
 			return foobar$ as custom_sig_T
 		}, { id: 'foobar', ns: 'test_ns' }))

package/all/is_development/index.js

@@ -4,6 +4,7 @@ export const [
 	is_development$_,
 	is_development_,
 ] = be_memo_pair_(ctx=>
-	NODE_ENV_(ctx) === 'dev' || NODE_ENV_(ctx) === 'development',
+	NODE_ENV_(ctx) === 'dev'
+		|| NODE_ENV_(ctx) === 'development',
 { id: 'is_development' })
 export { is_development$_ as is_development__ }

package/all/is_production/index.js

@@ -4,7 +4,8 @@ export const [
 	is_production$_,
 	is_production_,
 ] = be_memo_pair_(ctx=>
-	NODE_ENV_(ctx) === 'prod' || NODE_ENV_(ctx) === 'production',
+	NODE_ENV_(ctx) === 'prod'
+		|| NODE_ENV_(ctx) === 'production',
 { id: 'is_production' })
 export {
 	is_production$_ as is_production__,

package/all/rmemo/index.d.ts

@@ -1,23 +1,11 @@
 /// <reference lib="es2021" />
-export declare function memo_<val_T>(
-	def:memo_def_T<val_T>,
-	...subscriber_a:memo_subscriber_T<val_T>[]
-):memo_T<val_T>
-export declare function sig_<val_T>(
-	init_val:val_T,
-	...subscriber_a:memo_subscriber_T<val_T>[]
-):sig_T<val_T>
-export declare function memosig_<val_T>(
-	def:memo_def_T<val_T>,
-	...subscriber_a:memo_subscriber_T<val_T>[]
-):sig_T<val_T>
-export declare function lock_memosig_<val_T>(
-	def:memo_def_T<val_T>,
-	...subscriber_a:memo_subscriber_T<val_T>[]
-):sig_T<val_T>
+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__subscribe(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>void
+export declare function rmemo__add(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>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)&{
@@ -25,23 +13,29 @@ export type memo_T<val_T> = (()=>val_T)&{
 	readonly val:val_T
 	r?:WeakRef<()=>val_T>
 	memor:WeakRef<()=>val_T>[]
-	b?:[unknown, memo_T<unknown>][]
+	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>
+}
+export interface circular_memo_T extends memo_T<circular_memo_T> {
 }
-export interface circular_memo_T extends memo_T<circular_memo_T> {}
 export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
 	readonly val:val_T
 	r?:WeakRef<()=>val_T>
 	memor:WeakRef<()=>val_T>[]
-	b?:[unknown, memo_T<unknown>][]
+	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>
+}
+export interface circular_sig_T extends sig_T<circular_sig_T> {
 }
-export interface circular_sig_T extends sig_T<circular_sig_T> {}
 export type lock_memosig_T<val_T> = sig_T<val_T>&{
 	lock?:0|1
 }
-export interface circular_lock_memosig_T extends lock_memosig_T<circular_lock_memosig_T> {}
+export interface circular_lock_memosig_T extends lock_memosig_T<circular_lock_memosig_T> {
+}
 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 memo_subscriber_T<val_T> = (sig:sig_T<val_T>)=>unknown
+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

package/all/rmemo/index.js

@@ -5,11 +5,11 @@ let cur_memo
 let queue = new Set
 /**
  * @param {memo_def_T}memo_def
- * @param {memo_subscriber_T<unknown>[]}subscriber_a
+ * @param {rmemo_add_T<unknown>[]}add_def_a
  * @returns {memo_T}
  * @private
  */
-export function memo_(memo_def, ...subscriber_a) {
+export function memo_(memo_def, ...add_def_a) {
 	let memo = ()=>{
 		if (!('val' in memo)) {
 			memo.f()
@@ -17,9 +17,9 @@ export function memo_(memo_def, ...subscriber_a) {
 		if (cur_memo) {
 			if (!memo.memor.includes(cur_memo.r ||= new WeakRef(cur_memo.f))) memo.memor.push(cur_memo.r)
 			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
-			// conditional in r calls this r_memo
+			// memo is called by cur_memo's conditional execution...next change to memo will notify cur_memo
 			cur_memo.f.s.push(memo)
-			// prevent this rmemo from GC while cur_memo is still active
+			// 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)
 		}
 		return memo.val
@@ -27,46 +27,52 @@ export function memo_(memo_def, ...subscriber_a) {
 	Object.defineProperty(memo, '_', {
 		get: memo,
 		set: val=>{
-			let run_queue
 			if (memo.val !== val) {
-				run_queue = !queue.size
 				memo.memor = memo.memor.filter(r=>{
 					r = r.deref()
-					if (r && r.s.includes(memo)) { // if conditional r refresh calls this r_memo, add to queue
+					if (r && r.s.includes(memo)) { // if added by cur_memo.f.s.push(memo), add to queue
 						queue.add(r)
 					}
 					return r
 				})
 			}
 			memo.val = val
-			if (!memo.b) {
-				memo.b = subscriber_a.map(subscriber=>memo_(()=>subscriber(memo)))
-				memo.b = memo.b.map(subscriber_memo=>[subscriber_memo(), subscriber_memo])
+			if (!memo.a) {
+				memo.a = []
+				add_def_a.map(memo.add)
 			}
-			if (run_queue) {
-				cur_refresh_loop:for (let cur_refresh of queue) {
-					queue.delete(cur_refresh)
-					for (let queue_refresh of queue) {
-						if (cur_refresh.l > queue_refresh.l) {
-							queue.add(cur_refresh)
-							continue cur_refresh_loop
-						}
+			cur_refresh_loop:for (let cur_refresh of queue) {
+				queue.delete(cur_refresh)
+				for (let queue_refresh of queue) {
+					if (cur_refresh.l > queue_refresh.l) {
+						queue.add(cur_refresh)
+						continue cur_refresh_loop
 					}
-					cur_refresh()
 				}
+				cur_refresh()
 			}
 		},
 	})
+	memo.add = add_def=>{
+		if (memo.a) {
+			let pair = [memo_(()=>pair[1] = add_def(memo, pair[1]))]
+			memo.a.push(pair)
+			pair[0]()
+		} else {
+			add_def_a.push(add_def)
+		}
+		return memo
+	}
 	memo.f = ()=>{
 		let prev_memo = cur_memo
 		cur_memo = memo
-		memo.f.s = []
+		memo.f.s = [] // reset references in memo_def conditional execution path...see cur_memo.f.s.push(memo)
 		try {
 			memo._ = memo_def(memo)
 		} catch (err) {
 			console.error(err)
 		}
-		cur_memo = prev_memo // finally is not necessary...catch does not throw
+		cur_memo = prev_memo // catch does not throw
 	}
 	memo.f.l = 0
 	memo.f.s = []
@@ -77,16 +83,25 @@ export function memo_(memo_def, ...subscriber_a) {
 export { memo_ as memosig_ }
 /**
  * @param {memo_def_T}memo_def
- * @param {memo_subscriber_T<unknown>[]}subscriber_a
+ * @param {rmemo_add_T<unknown>[]}subscriber_a
  * @returns {sig_T}
  * @private
  */
 export function lock_memosig_(memo_def, ...subscriber_a) {
-	return new Proxy(
+	let lock_memosig = new Proxy(
 		/** @type {sig_T} */memo_(memo=>
 			memo.lock ? memo._ : memo_def(memo),
 		...subscriber_a),
 		{
+			get(memo, prop) {
+				if (prop === 'add') {
+					return (...arg_a)=>{
+						memo[prop](...arg_a)
+						return lock_memosig
+					}
+				}
+				return memo[prop]
+			},
 			set(memo, prop, val) {
 				if (prop === '_') {
 					memo.lock = 1
@@ -95,20 +110,20 @@ export function lock_memosig_(memo_def, ...subscriber_a) {
 				return 1
 			}
 		})
+	return lock_memosig
 }
 /**
  * @param {unknown}init_val
- * @param {memo_subscriber_T[]}subscriber_a
+ * @param {rmemo_add_T[]}add_a
  * @returns {sig_T}
  * @private
  */
-export function sig_(init_val, ...subscriber_a) {
-	return memo_(sig=>{
-		return 'val' in sig
+export function sig_(init_val, ...add_a) {
+	return memo_(sig=>
+		'val' in sig
 			? sig.val
-			: init_val
-	},
-	...subscriber_a)
+			: init_val,
+	...add_a)
 }
 /**
  * Call the rmemo & enable updates from it's parents.
@@ -132,20 +147,21 @@ export function rmemo__off(rmemo) {
 	}
 }
 /**
- * Bind reactive listener onto the given memo to prevent GC.
- * The listener can autosubscribe to any rmemo.
- * Returns an "off" function which deactivates the reactive listener & removes the GC binding from the given memo.
+ * 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}listener
+ * @param {()=>unknown}add_def
  * @returns {()=>void}
  */
-export function rmemo__subscribe(memo, listener) {
-	let listener_memo = memo_(()=>listener())
-	listener_memo()
-	memo.b ??= []
-	memo.b.push(listener_memo)
+export function rmemo__add(memo, add_def) {
+	let pair
+	memo.add(()=>{
+		pair = memo.a[memo.a.length - 1]
+		return add_def(memo)
+	})
 	return ()=>{
-		rmemo__off(listener_memo)
-		memo.b.splice(memo.b.indexOf(listener_memo), 1)
+		rmemo__off(pair[0])
+		memo.a.splice(memo.a.indexOf(pair), 1)
 	}
 }

package/all/rmemo/index.test.ts

@@ -4,7 +4,7 @@ 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__subscribe, sig_ } from './index.js'
+import { lock_memosig_, memo_, type memo_T, memosig_, rmemo__off, rmemo__on, rmemo__add, sig_ } from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
 	const memo = memo_(()=>{
@@ -171,23 +171,29 @@ test('sig_|undefined', ()=>{
 	equal(sig(), undefined)
 	equal(memo(), undefined)
 })
-test('rmemo|subscriber|has strong refernce to the return value', ()=>{
+test('rmemo|subscriber|has strong reference to the return value', ()=>{
+	const add_arg_aa:[memo_T<number|undefined>, number|undefined][] = []
 	const num$ = sig_<number|undefined>(
-		undefined,
-		()=>99)
-	equal(num$.b, undefined)
+		undefined
+	).add<number>((sig, old_val)=>{
+		add_arg_aa.push([sig, old_val])
+		return 99
+	})
+	equal(num$.a, undefined)
+	equal(add_arg_aa, [])
 	equal(num$(), undefined)
-	equal(num$.b![0][0], 99)
+	equal(num$.a![0][1], 99)
+	equal(add_arg_aa, [[num$, undefined]])
 })
 test('sig_|subscriber|notified if sig is set before read', ()=>{
 	let count = 0
 	let subscriber__num:number|undefined = undefined
 	const num$ = sig_<number|undefined>(
-		undefined,
-		num$=>{
-			count++
-			subscriber__num = num$()
-		})
+		undefined
+	).add(num$=>{
+		count++
+		subscriber__num = num$()
+	})
 	equal(count, 0)
 	equal(subscriber__num, undefined)
 	num$._ = 1
@@ -201,11 +207,11 @@ test('sig_|subscriber|sets sig', ()=>{
 	const base$ = sig_(0)
 	let count = 0
 	const num$ = sig_(
-		0,
-		async num$=>{
-			count++
-			num$._ = base$() + 1
-		})
+		0
+	).add(async num$=>{
+		count++
+		num$._ = base$() + 1
+	})
 	equal(count, 0)
 	equal(num$(), 1)
 	equal(count, 1)
@@ -220,13 +226,13 @@ test('sig_|async subsubscriber|case 1', async ()=>{
 	const id$ = sig_('id-0')
 	let count = 0
 	const user$ = sig_<{ id:string }|null>(
-		null,
-		async (_user$)=>{
-			count++
-			id$()
-			const user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
-			_user$._ = user
-		})
+		null
+	).add(async (_user$)=>{
+		count++
+		id$()
+		const user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
+		_user$._ = user
+	})
 	equal(count, 0)
 	equal(user$(), null)
 	equal(count, 1)
@@ -247,14 +253,15 @@ test('sig_|async subsubscriber|case 2', async ()=>{
 	const b$ = sig_(2)
 	const sleepCycles = 5
 	const taskArgumentsCalls:number[][] = []
-	const sum$ = sig_<null|number>(null,
-		async sum$=>{
-			taskArgumentsCalls.push([a$(), b$()])
-			for (let i = 0; i < sleepCycles; i++) {
-				await Promise.resolve()
-			}
-			sum$._ = a$() + b$()
-		})
+	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$()
+	})
 	equal(sum$(), null)
 	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
 	a$._ = 10
@@ -303,10 +310,10 @@ test('prevents diamond dependency problem 1', ()=>{
 	const b$ = memo_(()=>a$().replace('a', 'b'))
 	const c$ = memo_(()=>a$().replace('a', 'c'))
 	const d$ = memo_(()=>a$().replace('a', 'd'))
-	memo_(()=>`${b$()}${c$()}${d$()}`,
-		combined$=>
-			values.push(combined$())
-	)()
+	memo_(
+		()=>`${b$()}${c$()}${d$()}`)
+		.add(combined$=>values.push(combined$()))
+		()
 	deepStrictEqual(values, ['b0c0d0'])
 	store$._ = 1
 	store$._ = 2
@@ -321,9 +328,9 @@ test('prevents diamond dependency problem 2', ()=>{
 	const d$ = memo_(()=>c$().replace('c', 'd'))
 	const e$ = memo_(()=>d$().replace('d', 'e'))
 	memo_<string>(
-		()=>[a$(), e$()].join(''),
-		$=>values.push($())
-	)()
+		()=>[a$(), e$()].join(''))
+		.add($=>values.push($()))
+		()
 	deepStrictEqual(values, ['a0e0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
@@ -336,9 +343,9 @@ test('prevents diamond dependency problem 3', ()=>{
 	const c$ = memo_(()=>b$().replace('b', 'c'))
 	const d$ = memo_(()=>c$().replace('c', 'd'))
 	memo_<string>(
-		()=>`${a$()}${b$()}${c$()}${d$()}`,
-		combined$=>values.push(combined$())
-	)()
+		()=>`${a$()}${b$()}${c$()}${d$()}`)
+		.add(combined$=>values.push(combined$()))
+		()
 	deepStrictEqual(values, ['a0b0c0d0'])
 	store$._ = 1
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
@@ -355,13 +362,13 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 	const f$ = memo_(()=>`f${e$()}`)
 	const g$ = memo_(()=>`g${f$()}`)
 	memo_(
-		()=>e$(),
-		combined1$=>values.push(combined1$())
-	)()
+		()=>e$())
+		.add(combined1$=>values.push(combined1$()))
+		()
 	memo_(
-		()=>[e$(), g$()].join(''),
-		combined2$=>values.push(combined2$())
-	)()
+		()=>[e$(), g$()].join(''))
+		.add(combined2$=>values.push(combined2$()))
+		()
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
 	store1$._ = 1
 	store2$._ = 2
@@ -408,9 +415,9 @@ test('prevents diamond dependency problem 6', ()=>{
 	const b$ = memo_(()=>`b${store2$()}`)
 	const c$ = memo_(()=>b$().replace('b', 'c'))
 	memo_(
-		()=>`${a$()}${c$()}`,
-		combined$=>values.push(combined$())
-	)()
+		()=>`${a$()}${c$()}`)
+		.add(combined$=>values.push(combined$()))
+		()
 	deepStrictEqual(values, ['a0c0'])
 	store1$._ = 1
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
@@ -421,9 +428,9 @@ test('prevents dependency listeners from being out of order', ()=>{
 		return `${base$()}a`
 	})
 	const values:string[] = []
-	const b$ = memo_(()=>{
-		return `${a$()}b`
-	}, b$=>values.push(b$()))
+	const b$ = memo_(
+		()=>`${a$()}b`)
+		.add(b$=>values.push(b$()))
 	equal(b$(), '0ab')
 	deepStrictEqual(values, ['0ab'])
 	equal(a$(), '0a')
@@ -462,14 +469,17 @@ test('.rmemo__on + .rmemo__off', ()=>{
 	equal(memo$(), 14)
 	equal(count, 5)
 })
-test('rmemo__subscribe', ()=>{
+test('rmemo__add', ()=>{
 	const base$ = sig_(1)
 	let count = 0
 	const subscriber_base_a:number[] = []
-	const off = rmemo__subscribe(base$, ()=>{
+	const off = rmemo__add(base$, ()=>{
 		count++
 		subscriber_base_a.push(base$())
 	})
+	equal(subscriber_base_a, [])
+	equal(count, 0)
+	base$()
 	equal(subscriber_base_a, [1])
 	equal(count, 1)
 	base$._ = 2

package/all/waitfor/index.test.ts

@@ -9,7 +9,7 @@ test('waitfor|success', async ()=>{
 	const promise = waitfor(()=>{
 		count++
 		return ret
-	}, 10)
+	}, 50)
 		.then(returned_value=>{
 			returned_value_a.push(returned_value)
 			return returned_value
@@ -40,7 +40,7 @@ test('waitfor|cancel', async ()=>{
 	const promise = waitfor(()=>{
 		count++
 		return false
-	}, 10)
+	}, 50)
 	equal(count, 1)
 	equal(await promise.cancel(), false)
 	equal(count, 1)
@@ -50,7 +50,7 @@ test('waitfor|cancel', async ()=>{
 	const undefinable_promise = waitfor<boolean|undefined>(()=>{
 		count++
 		return false
-	}, 10)
+	}, 50)
 	equal(count, 1)
 	equal(await undefinable_promise.cancel(undefined), undefined)
 	equal(count, 1)
@@ -63,7 +63,7 @@ test('waitfor|period|number', async ()=>{
 	const promise = waitfor(()=>{
 		count++
 		return ret
-	}, 10, 2)
+	}, 50, 2)
 	try {
 		equal(count, 1)
 		await sleep(2)
@@ -85,7 +85,7 @@ test('waitfor|period|async function', async ()=>{
 	const promise = waitfor(()=>{
 		count++
 		return ret
-	}, 10, (...arg_a)=>{
+	}, 50, (...arg_a)=>{
 		period_arg_aa.push(arg_a)
 		return sleep(2)
 	})

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ctx-core",
-	"version": "5.15.0",
+	"version": "5.16.1",
 	"description": "ctx-core core library",
 	"keywords": [
 		"ctx-core",
@@ -210,28 +210,28 @@
 			"import": {
 				"./rmemo": "{ memo_ }"
 			},
-			"limit": "335 B"
+			"limit": "355 B"
 		},
 		{
 			"name": "memo_ sig_",
 			"import": {
 				"./rmemo": "{ sig_, memo_ }"
 			},
-			"limit": "353 B"
+			"limit": "377 B"
 		},
 		{
 			"name": "memo_ sig_ be_ ctx_",
 			"import": {
 				"./rmemo": "{ sig_, memo_, be_, ctx_ }"
 			},
-			"limit": "460 B"
+			"limit": "478 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": "553 B"
+			"limit": "580 B"
 		},
 		{
 			"name": "uuid",

package/rmemo/index.d.ts

@@ -1,5 +1,5 @@
-import { rmemo__off, rmemo__on, rmemo__subscribe } from '../rmemo/index.js'
-export { rmemo__off as off, rmemo__on as on, rmemo__subscribe as subscribe }
+import { rmemo__off, rmemo__on, rmemo__add } from '../rmemo/index.js'
+export { rmemo__off as off, rmemo__on as on, rmemo__add as subscribe }
 export * from '../all/be/index.js'
 export * from '../all/be_/index.js'
 export * from '../all/be_lock_memosig_triple/index.js'

package/rmemo/index.js

@@ -1,5 +1,5 @@
-import { rmemo__off, rmemo__on, rmemo__subscribe } from '../rmemo/index.js'
-export { rmemo__off as off, rmemo__on as on, rmemo__subscribe as subscribe }
+import { rmemo__off, rmemo__on, rmemo__add } from '../rmemo/index.js'
+export { rmemo__off as off, rmemo__on as on, rmemo__add as subscribe }
 export * from '../all/be/index.js'
 export * from '../all/be_/index.js'
 export * from '../all/be_lock_memosig_triple/index.js'