ctx-core 6.8.2 → 7.0.0

package/all/be_sig_triple/index.test.ts

@@ -18,10 +18,10 @@ test('be_sig_triple_', ()=>{
 		return 1
 	})
 	const ctx = ctx__new()
-	equal(foobar$_(ctx)._, 1)
+	equal(foobar$_(ctx)(), 1)
 	equal(foobar_(ctx), 1)
 	foobar__set(ctx, 2)
-	equal(foobar$_(ctx)._, 2)
+	equal(foobar$_(ctx)(), 2)
 	equal(foobar_(ctx), 2)
 })
 test('be_sig_triple_|+id|+ns|+add', ()=>{
@@ -31,37 +31,42 @@ test('be_sig_triple_|+id|+ns|+add', ()=>{
 		,
 		add_dep_,
 		add_dep__set
-	] = be_sig_triple_(()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_sig_triple_<number, 'test_ns'>(
+	] = ns_id_be_sig_triple_<number, 'test_ns'>(
+		'test_ns',
+		'foobar',
 		ctx=>{
 			/* eslint-disable @typescript-eslint/no-unused-vars */
 			type test_ctx = Expect<Equal<typeof ctx, wide_ctx_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
-		}, { id: 'foobar', ns: 'test_ns' }
-	).add((ctx, foobar$)=>memo_(()=>{
-		add_count++
-		add_dep__set(ctx, add_count + foobar$())
-	}))
+		},
+		[
+			(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_(ns_ctx__new(ctx__new(), ctx)), 1)
-	equal(foobar$_(ctx)._, 1)
+	equal(foobar$_(ctx)(), 1)
 	equal(foobar_(ctx), 1)
 	equal(add_count, 1)
 	equal(add_dep_(ctx), 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 1)
+	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)
+	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(foobar_(ctx), 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)(), 2)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 4)
 })
@@ -79,25 +84,25 @@ test('be_sig_triple_|+be', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ =
 				sig_<number, { custom:string }>(
-					1
-				).add(()=>add_count++)
+					1,
+					[()=>add_count++])
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', ns: 'test_ns' }))
 	equal(add_count, 0)
-	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
+	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(foobar_(ctx), 1)
 	equal(add_count, 1)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 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)
-	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	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(foobar_(ctx), 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)(), 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 1)
 })
@@ -122,22 +127,24 @@ test('ns_be_sig_triple_', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, wide_ctx_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
-		}
-	).add((ctx, foobar$)=>memo_(()=>{
-		add_count++
-		add_dep__set(ctx, add_count + foobar$())
-	}))
+		},
+		[
+			(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_(ns_ctx__new(ctx__new(), ctx)), 1)
-	equal(foobar$_(ctx)._, 1)
+	equal(foobar$_(ctx)(), 1)
 	equal(foobar_(ctx), 1)
 	equal(add_count, 1)
 	equal(add_dep_(ctx), 2)
 	foobar__set(ns_ctx__new(ctx__new(), ctx), 2)
-	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	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(foobar_(ctx), 2)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 4)
@@ -163,21 +170,23 @@ test('id_be_sig_triple_', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, wide_ctx_T<''>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
-		}
-	).add((ctx, foobar$)=>memo_(()=>{
-		add_count++
-		add_dep__set(ctx, add_count + foobar$())
-	}))
+		},
+		[
+			(ctx, foobar$)=>memo_(()=>{
+				add_count++
+				add_dep__set(ctx, add_count + foobar$())
+			})
+		])
 	equal(add_count, 0)
-	equal(foobar$_(ctx)._, 1)
+	equal(foobar$_(ctx)(), 1)
 	equal(foobar_(ctx), 1)
 	equal(add_count, 1)
 	equal(add_dep_(ctx), 2)
-	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 1)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)(), 1)
 	foobar__set(ctx, 2)
-	equal(foobar$_(ctx)._, 2)
+	equal(foobar$_(ctx)(), 2)
 	equal(foobar_(ctx), 2)
-	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 2)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)(), 2)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 4)
 })
@@ -204,24 +213,26 @@ test('ns_id_be_sig_triple_', ()=>{
 			type test_ctx = Expect<Equal<typeof ctx, wide_ctx_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return 1
-		}).add((ctx, foobar$)=>memo_(()=>{
-		add_count++
-		add_dep__set(ctx, add_count + foobar$())
-	}))
+		}, [
+			(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_(ns_ctx__new(ctx__new(), ctx)), 1)
-	equal(foobar$_(ctx)._, 1)
+	equal(foobar$_(ctx)(), 1)
 	equal(foobar_(ctx), 1)
 	equal(add_count, 1)
 	equal(add_dep_(ctx), 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 1)
+	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)
+	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(foobar_(ctx), 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)(), 2)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 4)
 })

package/all/event_log/index.js

@@ -1,18 +1,20 @@
-import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { be_sig_triple_, id_be_sig_triple_ } from '../be_sig_triple/index.js'
 import { memo_ } from '../rmemo/index.js'
 const [
 	event_log$_,
 	event_log_,
 	event_log__set,
-] = be_sig_triple_(
+] = id_be_sig_triple_(
+	'event_log',
 	()=>[],
-	{ id: 'event_log' }
-).add((ctx, event_log$)=>
-	memo_(()=>{
-		if (event_log$().length > event_log_limit_(ctx)) {
-			event_log$().splice(event_log$().length - event_log_limit_(ctx) + 1)
-		}
-	}))
+	[
+		(ctx, event_log$)=>
+			memo_(()=>{
+				if (event_log$().length > event_log_limit_(ctx)) {
+					event_log$().splice(event_log$().length - event_log_limit_(ctx) + 1)
+				}
+			})
+	])
 export {
 	event_log$_,
 	event_log_,

package/all/is_development/index.js

@@ -1,10 +1,11 @@
-import { be_memo_pair_ } from '../be_memo_pair/index.js'
+import { id_be_memo_pair_ } from '../be_memo_pair/index.js'
 import { NODE_ENV_ } from '../NODE_ENV/index.js'
 export const [
 	is_development$_,
 	is_development_,
-] = be_memo_pair_(ctx=>
-	NODE_ENV_(ctx) === 'dev'
-		|| NODE_ENV_(ctx) === 'development',
-{ id: 'is_development' })
+] = id_be_memo_pair_(
+	'is_development',
+	ctx=>
+		NODE_ENV_(ctx) === 'dev'
+		|| NODE_ENV_(ctx) === 'development')
 export { is_development$_ as is_development__ }

package/all/is_production/index.js

@@ -1,12 +1,13 @@
-import { be_memo_pair_ } from '../be_memo_pair/index.js'
+import { id_be_memo_pair_ } from '../be_memo_pair/index.js'
 import { NODE_ENV_ } from '../NODE_ENV/index.js'
 export const [
 	is_production$_,
 	is_production_,
-] = be_memo_pair_(ctx=>
-	NODE_ENV_(ctx) === 'prod'
-		|| NODE_ENV_(ctx) === 'production',
-{ id: 'is_production' })
+] = id_be_memo_pair_(
+	'is_production',
+	ctx=>
+		NODE_ENV_(ctx) === 'prod'
+		|| NODE_ENV_(ctx) === 'production')
 export {
 	is_production$_ as is_production__,
 	is_production$_ as b__is__production,

package/all/is_staging/index.js

@@ -1,11 +1,12 @@
-import { be_memo_pair_ } from '../be_memo_pair/index.js'
+import { id_be_memo_pair_ } from '../be_memo_pair/index.js'
 import { NODE_ENV_ } from '../NODE_ENV/index.js'
 export const [
 	is_staging$_,
 	is_staging_,
-] = be_memo_pair_(ctx=>
-	NODE_ENV_(ctx) === 'staging',
-{ id: 'is_staging' })
+] = id_be_memo_pair_(
+	'is_staging',
+	ctx=>
+		NODE_ENV_(ctx) === 'staging')
 export {
 	is_staging$_ as is_staging__,
 	is_staging$_ as b__is__staging,

package/all/rmemo/index.d.ts

@@ -1,14 +1,30 @@
 /// <reference lib="es2021" />
-export declare function memo_<val_T, E = unknown>(def:memo_def_T<val_T, E>):memo_T<val_T, E>
-export declare function sig_<val_T, E = unknown>(init_val:val_T):sig_T<val_T, E>
-export declare function memosig_<val_T, E = unknown>(def:memo_def_T<val_T, E>):sig_T<val_T, E>
-export declare function lock_memosig_<val_T, E = unknown>(def:memo_def_T<val_T, E>):sig_T<val_T, E>
+import type { wide_ctx_T } from '../be_/index.js'
+export declare function memo_<val_T, E = unknown>(
+	def:memo_def_T<val_T, E>,
+	add_def_a1?:rmemo_add_def_T<val_T, E>[]
+):memo_T<val_T, E>
+export declare function sig_<val_T, E = unknown>(
+	init_val:val_T,
+	add_def_a1?:rmemo_add_def_T<val_T, E>[]
+):sig_T<val_T, E>
+export declare function memosig_<val_T, E = unknown>(
+	def:memo_def_T<val_T, E>,
+	add_def_a1?:rmemo_add_def_T<val_T, E>[]
+):sig_T<val_T, E>
+export declare function lock_memosig_<val_T, E = unknown>(
+	def:memo_def_T<val_T, E>,
+	add_def_a1?:rmemo_add_def_T<val_T, E>[]
+):sig_T<val_T, E>
 export declare function memo__bind<A extends unknown[], R, E = unknown>(
 	fn:(...arg_a:A)=>R
 ):memo__bind_T<A, R, E>
 export type memo__bind_T<A extends unknown[], R, E = unknown> =
 	((...arg_a:A)=>R)&{
-	memo_<val_T>(def:memo_def_T<val_T, E>):memo_T<val_T>
+	memo_<val_T>(
+		def:memo_def_T<val_T, E>,
+		add_def_a1?:rmemo_add_def_T<val_T, E>[]
+	):memo_T<val_T>
 }
 export declare function rmemo__on<val_T, E = unknown>(rmemo:rmemo_T<val_T, E>, off_fn?:(rmemo:rmemo_T<val_T, E>)=>unknown):void
 export declare function rmemo__off<val_T, E = unknown>(rmemo:rmemo_T<val_T, E>):void
@@ -17,37 +33,31 @@ export declare function rmemo__add<val_T, listener_val_T, E = unknown>(
 	rmemo:rmemo_T<val_T, E>,
 	listener:(sig:sig_T<val_T, E>)=>listener_val_T
 ):()=>void
-export declare function rmemo__unset(rmemo:rmemo_T<unknown>):void
+export declare function rmemo__unset<T>(rmemo:rmemo_T<T>):void
 export type rmemo_T<val_T, E = unknown> = memo_T<val_T, E>|sig_T<val_T, E>|lock_memosig_T<val_T, E>
 export type rmemolike_T<val_T, E = unknown> = (()=>val_T)&E
 export type circular_rmemo_T<E = unknown> =
 	(circular_memo_T|circular_sig_T|circular_lock_memosig_T)&E
 export type memo_T<val_T, E = unknown> = (()=>val_T)&{
-	readonly _:val_T
+	memo_<_val_T, E = unknown>(
+		def:memo_def_T<_val_T>,
+		add_def_a1?:rmemo_add_def_T<val_T, E>[]
+	):memo_T<_val_T, E>
+	val:val_T
 	readonly a?:rmemo_a_T
-	readonly f?:rmemo_f_T
-	readonly s?:rmemo_r_T
-	readonly t:rmemo_r_T[]
+	readonly b:rmemo_add_def_T<val_T, E>[]
+	readonly d:()=>val_T
 	readonly l:number
+	readonly r:rmemo_r_T[]
 	readonly u:rmemo_T<unknown>[]
-	readonly v:rmemo_T<unknown>[]
-	readonly val:val_T
-	add<add_val_T>(add_def:rmemo_add_def_T<val_T, add_val_T>):memo_T<val_T, E>
-	memo_<_val_T, E = unknown>(def:memo_def_T<_val_T>):memo_T<_val_T, E>
+	readonly t:rmemo_T<unknown>[]
 }&E
 interface _circular_memo_T extends memo_T<_circular_memo_T> {
 }
 export type circular_memo_T<E = unknown> = _circular_memo_T&E
-export type sig_T<val_T, E = unknown> = (()=>val_T)&{
-	_:val_T
-	readonly a?:rmemo_a_T
-	readonly f?:rmemo_f_T
-	readonly l:number
-	readonly t:rmemo_T<unknown>[]
-	readonly val:val_T
-	add<add_val_T>(fn:rmemo_add_def_T<val_T, add_val_T>):sig_T<val_T, E>
-	memo_<_val_T, E = unknown>(def:memo_def_T<_val_T>):memo_T<_val_T, E>
-}&E
+export type sig_T<val_T, E = unknown> = memo_T<val_T, E>&{
+	set(val:val_T):void
+}
 interface _circular_sig_T extends sig_T<_circular_sig_T> {
 }
 export type circular_sig_T<E = unknown> = _circular_memo_T&E
@@ -62,10 +72,11 @@ export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 	: unknown
 export type memo_def_T<val_T, E = unknown> = (sig:sig_T<val_T, E>)=>val_T
 export type rmemo_a_T = unknown[]
-export type rmemo_add_def_T<val_T, add_val_T, E = unknown> = (sig:sig_T<val_T, E>)=>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 }
+export type rmemo_add_def_T<val_T, E = unknown> = (sig:sig_T<val_T, E>)=>unknown
+export type rmemo_r_T = WeakRef<rmemo_T<unknown>&{ readonly d?: ()=>rmemo_T<unknown> }>
+export type be_rmemo_add_def_T<
+	val_T,
+	ns_T extends string,
+	E = unknown,
+	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
+> = (ctx:ctx_T, sig:sig_T<val_T, E>)=>unknown

package/all/rmemo/index.js

@@ -7,93 +7,84 @@
 let $ = globalThis.__rmemo__ ??= { q: new Set }
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_def_T}add_def_a
+ * @param {rmemo_add_def_T[]}add_def_a1
  * @returns {memo_T}
  * @private
  */
-export function memo_(memo_def, ...add_def_a) {
+export function memo_(memo_def, add_def_a1) {
 	/** @type {memo_T} */
 	let memo = ()=>{
-		'val' in memo || memo.f()
+		'val' in memo || memo__run(memo)
 		if ($.c) {
-			if (!memo.t.includes($.c.s ??= new WeakRef($.c.f))) {
-				memo.t.push($.c.s)
+			if (!memo.r.includes($.c.s ??= new WeakRef($.c))) {
+				memo.r.push($.c.s)
 			}
-			if ($.c.f.l < memo.f.l + 1) $.c.f.l = memo.f.l + 1
+			if ($.c.l < memo.l + 1) $.c.l = memo.l + 1
 			// memo is called by $.c's conditional execution...next change to memo will notify $.c
-			$.c.f.s.push(memo)
+			$.c.u.push(memo)
 			// prevent memo from GC while $.c still has a strong reference
-			if (!$.c.f.t.includes(memo)) $.c.f.t.push(memo)
+			if (!$.c.t.includes(memo)) $.c.t.push(memo)
 		}
 		return memo.val
 	}
-	Object.defineProperty(memo, '_', {
-		get: memo,
-		set: val=>{
-			if (memo.val !== val) {
-				memo.t = memo.t.filter(r=>{
-					r = r.deref()
-					if (r?.s.includes(memo)) { // if added by $.c.f.s.push(memo), add to $.q
-						$.q.add(r)
-					}
-					return r
-				})
-			}
-			memo.val = val
-			if (!memo.a) {
-				memo.a = []
-				add_def_a.map(memo.add)
-			}
-			cur_refresh_loop:for (let cur_refresh of $.q) {
-				$.q.delete(cur_refresh)
-				for (let queue_refresh of $.q) {
-					if (cur_refresh.l > queue_refresh.l) {
-						$.q.add(cur_refresh)
-						continue cur_refresh_loop
-					}
+	memo.set = val=>{
+		if (memo.val !== val) {
+			memo.r = memo.r.filter(r=>{
+				r = r.deref()
+				if (r?.u.includes(memo)) { // if added by $.c.u.push(memo), add to $.q
+					$.q.add(r)
 				}
-				cur_refresh()
-			}
-		},
-	})
-	/**
-	 * @param {rmemo_add_def_T}add_def
-	 * @returns {memo_T}
-	 */
-	memo.add = add_def=>{
-		if (memo.a) {
-			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 r
+			})
 		}
-		return memo
-	}
-	memo.memo_ = memo_
-	memo.f = ()=>{
-		let prev_memo = $.c
-		$.c = memo
-		memo.f.s = [] // reset references in memo_def conditional execution path...see $.c.f.s.push(memo)
-		try {
-			memo._ = memo_def(memo)
-		} catch (err) {
-			console.error(err)
+		memo.val = val
+		if (!memo.a) {
+			memo.a = []
+			add_def_a1.map(add_def=>{
+				let v = add_def(memo)
+				if (v instanceof Object) {
+					memo.a.push(v)
+					if (v.memo_) v()
+				}
+			})
+		}
+		cur_refresh_loop:for (let cur_memo of $.q) {
+			$.q.delete(cur_memo)
+			for (let queue_refresh of $.q) {
+				if (cur_memo.l > queue_refresh.l) {
+					$.q.add(cur_memo)
+					continue cur_refresh_loop
+				}
+			}
+			memo__run(cur_memo)
 		}
-		$.c = prev_memo // catch does not throw
 	}
-	memo.f.l = 0
-	memo.f.s = []
-	memo.f.t = []
+	memo.l = 0
+	memo.d = memo_def
+	memo.b = add_def_a1 ??= []
+	memo.r = []
+	memo.u = []
 	memo.t = []
+	memo.memo_ = memo_
 	return memo
 }
 export { memo_ as memosig_ }
+/**
+ * @param {unknown}init_val
+ * @param {rmemo_add_def_T[]}add_def_a
+ * @returns {sig_T}
+ * @private
+ */
+export function sig_(init_val, add_def_a) {
+	return memo_(sig=>
+		'val' in sig
+			? sig.val
+			: init_val,
+	add_def_a)
+}
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_def_T}add_def_a
+ * @param {rmemo_add_def_T[]}add_def_a
  * @returns {sig_T}
  * @private
  */
@@ -105,37 +96,17 @@ export function lock_memosig_(memo_def, ...add_def_a) {
 		...add_def_a),
 		{
 			get(memo, prop) {
-				if (prop === 'add') {
-					return (...arg_a)=>{
-						memo[prop](...arg_a)
-						return lock_memosig
+				if (prop === 'set') {
+					return val=>{
+						memo.lock = 1
+						memo[prop](val)
 					}
 				}
 				return memo[prop]
 			},
-			set(memo, prop, val) {
-				if (prop === '_') {
-					memo.lock = 1
-					memo._ = val
-				}
-				return 1
-			}
 		})
 	return lock_memosig
 }
-/**
- * @param {unknown}init_val
- * @param {rmemo_add_def_T}add_def_a
- * @returns {sig_T}
- * @private
- */
-export function sig_(init_val, ...add_def_a) {
-	return memo_(sig=>
-		'val' in sig
-			? sig.val
-			: init_val,
-	...add_def_a)
-}
 /**
  * @param {(...arg_a:unknown[])=>unknown}fn
  * @returns {((...arg_a:unknown[])=>unknown)&{ memo_: typeof memo_ }}
@@ -156,7 +127,7 @@ export function rmemo__on(rmemo, off_fn) {
 	if (rmemo.s?.d) {
 		rmemo.s.deref = rmemo.s.d
 	}
-	rmemo.f()
+	memo__run(rmemo)
 	return rmemo
 }
 /**
@@ -198,11 +169,23 @@ export function rmemo__off__add(rmemo, off_fn) {
  */
 export function rmemo__add(memo, add_def) {
 	let val
-	memo.add((...arg_a)=>{
-		return val = add_def(...arg_a)
-	})
+	if (memo.a) {
+		val = add_def(memo)
+		if (val instanceof Object) {
+			memo.a.push(val)
+			if (val.memo_) val()
+		}
+	} else {
+		memo.b.push(()=>{
+			val = add_def(memo)
+			if (val instanceof Object) {
+				memo.a.push(val)
+				if (val.memo_) val()
+			}
+		})
+	}
 	return ()=>{
-		if (val.memo_) rmemo__off(val)
+		if (val?.memo_) rmemo__off(val)
 		if (val instanceof Object) memo.a.splice(memo.a.indexOf(val), 1)
 	}
 }
@@ -212,3 +195,14 @@ export function rmemo__add(memo, add_def) {
 export function rmemo__unset(rmemo) {
 	delete rmemo.val
 }
+function memo__run(memo) {
+	let prev_memo = $.c
+	$.c = memo
+	memo.u = [] // reset references in memo_def conditional execution path...see $.c.u.push(memo)
+	try {
+		memo.set(memo.d(memo))
+	} catch (err) {
+		console.error(err)
+	}
+	$.c = prev_memo // catch does not throw
+}