ctx-core 5.15.0 → 5.16.0

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)
@@ -89,13 +89,13 @@ test('be_lock_memosig_triple_|+id|+ns', ()=>{
 	equal(subscriber_count, 2)
 	equal(subscriber_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((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
-	equal(subscriber_dep_(ctx), 7)
+	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((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 3)
+	equal(subscriber_dep_(ctx), 6)
 })
 test('be_lock_memosig_triple_|+be', ()=>{
 	const ctx = ns_ctx__new('test_ns')
@@ -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,7 +83,7 @@ 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
  */
@@ -98,17 +104,16 @@ export function lock_memosig_(memo_def, ...subscriber_a) {
 }
 /**
  * @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 +137,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)
 	}
 }