ctx-core 6.8.3 → 7.0.1

package/all/be_/index.d.ts

@@ -101,6 +101,30 @@ export declare function ondelete_be_<
 	val__new:ondelete_be__val__new_T<val_T, ns_T, ctx_T>,
 	config?:be_config_T<ns_T>
 ):ondelete_Be<val_T, ns_T, ctx_T>
+export declare function ns_ondelete_be_<
+	val_T,
+	ns_T extends string,
+	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:ondelete_be__val__new_T<val_T, ns_T, ctx_T>
+):ondelete_Be<val_T, ns_T, ctx_T>
+export declare function id_ondelete_be_<
+	val_T,
+	ctx_T extends wide_ctx_T<''> = wide_ctx_T<''>,
+>(
+	id:string,
+	val__new:ondelete_be__val__new_T<val_T, '', ctx_T>
+):ondelete_Be<val_T, '', ctx_T>
+export declare function ns_id_ondelete_be_<
+	val_T,
+	ns_T extends string,
+	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:be__val__new_T<val_T, ns_T, ctx_T>
+):ondelete_Be<val_T, ns_T, ctx_T>
 export type Be<
 	val_T,
 	ns_T extends string = '',

package/all/be_/index.js

@@ -199,3 +199,31 @@ export function ondelete_be_(val__new, config) {
 	}
 	return be
 }
+/**
+ * @param {string}ns
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function ns_ondelete_be_(ns, val__new) {
+	return ondelete_be_(val__new, { ns })
+}
+/**
+ * @param {string}id
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function id_ondelete_be_(id, val__new) {
+	return ondelete_be_(val__new, { id })
+}
+/**
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function ns_id_ondelete_be_(ns, id, val__new) {
+	return ondelete_be_(val__new, { ns, id })
+}

package/all/be_/index.test.ts

@@ -19,8 +19,11 @@ import {
 	type ctx_T,
 	globalThis__be_,
 	id_be_,
+	id_ondelete_be_,
 	ns_be_,
 	ns_id_be_,
+	ns_id_ondelete_be_,
+	ns_ondelete_be_,
 	ondelete_be_,
 	type wide_ctx_s_T,
 	type wide_ctx_T
@@ -460,6 +463,29 @@ test('ondelete_be_', ()=>{
 	equal(ondelete0_arg_aa, [[1, ctx, be], [1, ctx, be]])
 	equal(ondelete1_arg_aa, [[1, ctx, be], [1, ctx, be]])
 })
+test('ns_ondelete_be_', ()=>{
+	const valid_ctx = ns_ctx__new('test_ns')
+	const val_ = ns_ondelete_be_('test_ns', ()=>true)
+	equal(val_(valid_ctx), true)
+	// @ts-expect-error TS2322
+	throws(()=>val_(ctx__new()))
+})
+test('id_ondelete_be_', ()=>{
+	const valid_ctx = ctx__new()
+	const val_ = id_ondelete_be_('test_id', ()=>true)
+	equal(val_(valid_ctx), true)
+	equal(val_.id, 'test_id')
+	// @ts-expect-error TS2322
+	throws(()=>val_(ns_ctx__new('test_ns')))
+})
+test('ns_id_ondelete_be_', ()=>{
+	const valid_ctx = ns_ctx__new('test_ns')
+	const val_ = ns_id_ondelete_be_('test_ns', 'test_id', ()=>true)
+	equal(val_(valid_ctx), true)
+	equal(val_.id, 'test_id')
+	// @ts-expect-error TS2322
+	throws(()=>val_(ctx__new()))
+})
 test('ctx__clear', ()=>{
 	const ondelete0_arg_aa:[val:number, ctx:ctx_T, be:Be<number, ''|'test_ns'>][] = []
 	const ondelete1_arg_aa:[val:number, ctx:ctx_T, be:Be<number, ''|'test_ns'>][] = []

package/all/be_lock_memosig_triple/index.d.ts

@@ -1,5 +1,5 @@
-import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, ctx__set_T, wide_ctx_T, } from '../be_/index.js'
-import type { lock_memosig_T } from '../rmemo/index.js'
+import type { Be, ctx__be_T, ctx__get_T, ctx__set_T, wide_ctx_T, } from '../be_/index.js'
+import type { lock_memosig_T, be_rmemo_add_def_T } from '../rmemo/index.js'
 export declare function be_lock_memosig_triple_<
 	val_T,
 	ns_T extends string = '',
@@ -13,7 +13,7 @@ export declare function be_lock_memosig_triple_<
 	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
 >(
 	val__new:(ctx:ctx_T, lock_memosig:lock_memosig_T<val_T, E>)=>val_T,
-	...config:be_config_arg_a_T<ns_T>
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
 export declare function ns_be_lock_memosig_triple_<
 	val_T,
@@ -23,6 +23,7 @@ export declare function ns_be_lock_memosig_triple_<
 >(
 	ns:ns_T,
 	val__new:(ctx:ctx_T, lock_memosig:lock_memosig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
 export declare function id_be_lock_memosig_triple_<
 	val_T,
@@ -31,6 +32,7 @@ export declare function id_be_lock_memosig_triple_<
 >(
 	id:string,
 	val__new:(ctx:ctx_T, lock_memosig:lock_memosig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, '', E, ctx_T>[]
 ):be_lock_memosig_triple_T<val_T, '', E, ctx_T>
 export declare function ns_id_be_lock_memosig_triple_<
 	val_T,
@@ -41,6 +43,7 @@ export declare function ns_id_be_lock_memosig_triple_<
 	ns:ns_T,
 	id:string,
 	val__new:(ctx:ctx_T, lock_memosig:lock_memosig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
 export type be_lock_memosig_triple_T<
 	val_T,
@@ -51,8 +54,4 @@ export type be_lock_memosig_triple_T<
 	ctx__be_T<lock_memosig_T<val_T, E>, ns_T, ctx_T>,
 	ctx__get_T<val_T, ns_T, ctx_T>,
 	ctx__set_T<val_T, ns_T, ctx_T>,
-]&{
-	add<add_val_T>(
-		add_def:(ctx:ctx_T, sig:lock_memosig_T<val_T, E>)=>add_val_T
-	):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
-}
+]

package/all/be_lock_memosig_triple/index.js

@@ -6,72 +6,75 @@ 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 {be_rmemo_add_def_T[]}[add_def_a1]
  * @param {be_config_T}[config]
  * @returns {be_lock_memosig_triple_T}
  * @private
  */
 export function be_lock_memosig_triple_(
 	be_OR_val__new,
+	add_def_a1,
 	config
 ) {
-	let add_def_a = []
 	/** @type {Be<sig_T>} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				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))),
+				lock_memosig_(
+					memo=>be_OR_val__new(ctx, memo),
+					(add_def_a1 ?? []).map(
+						add_def=>memo=>add_def(ctx, memo))),
 			config)
-	let be_lock_memosig_triple = [
+	return [
 		be,
 		ctx=>be(ctx)(),
 		(ctx, val)=>{
-			be(ctx)._ = val
+			be(ctx).set(val)
 		},
 	]
-	be_lock_memosig_triple.add = add_def=>{
-		add_def_a.push(add_def)
-		return be_lock_memosig_triple
-	}
-	return be_lock_memosig_triple
 }
 /**
  * @param {string}ns
  * @param {be__val__new_T<unknown>}val__new
+ * @param {be_rmemo_add_def_T[]}[add_def_a1]
  * @returns {be_lock_memosig_triple_T}
  * @private
  */
 export function ns_be_lock_memosig_triple_(
 	ns,
-	val__new
+	val__new,
+	add_def_a1
 ) {
-	return be_lock_memosig_triple_(val__new, { ns })
+	return be_lock_memosig_triple_(val__new, add_def_a1, { ns })
 }
 /**
  * @param {string}id
  * @param {be__val__new_T<unknown>}val__new
+ * @param {be_rmemo_add_def_T[]}[add_def_a1]
  * @returns {be_lock_memosig_triple_T}
  * @private
  */
 export function id_be_lock_memosig_triple_(
 	id,
-	val__new
+	val__new,
+	add_def_a1
 ) {
-	return be_lock_memosig_triple_(val__new, { id })
+	return be_lock_memosig_triple_(val__new, add_def_a1, { id })
 }
 /**
  * @param {string}ns
  * @param {string}id
  * @param {be__val__new_T<unknown>}val__new
+ * @param {be_rmemo_add_def_T[]}[add_def_a1]
  * @returns {be_lock_memosig_triple_T}
  * @private
  */
 export function ns_id_be_lock_memosig_triple_(
 	ns,
 	id,
-	val__new
+	val__new,
+	add_def_a1
 ) {
-	return be_lock_memosig_triple_(val__new, { ns, id })
+	return be_lock_memosig_triple_(val__new, add_def_a1, { ns, id })
 }

package/all/be_lock_memosig_triple/index.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_, type wide_ctx_T } from '../be_/index.js'
-import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { be_sig_triple_, ns_be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { memo_, memosig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
@@ -31,15 +31,15 @@ test('be_lock_memosig_triple_', ()=>{
 	})
 	const ctx = ctx__new()
 	equal(foobar$_(ctx).count, undefined)
-	equal(foobar$_(ctx)._, 2)
+	equal(foobar$_(ctx)(), 2)
 	equal(foobar_(ctx), 2)
 	equal(foobar$_(ctx).count, 1)
 	foobar__set(ctx, 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(foobar$_(ctx).count, 1)
 	base__set(ctx, 2)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(foobar$_(ctx).count, 1)
 })
@@ -50,54 +50,58 @@ test('be_lock_memosig_triple_|+id|+ns', ()=>{
 		,
 		base_,
 		base__set,
-	] = be_sig_triple_(
-		()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		,
 		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_lock_memosig_triple_<number, 'test_ns'>(
+	] = ns_id_be_lock_memosig_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 base_(ctx) + 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))._, 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, 1)
-	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_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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
-	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)(), 5)
 	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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(add_count, 2)
-	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)(), 5)
 	equal(add_dep_(ctx), 7)
 })
 test('be_lock_memosig_triple_|+be', ()=>{
@@ -107,50 +111,52 @@ test('be_lock_memosig_triple_|+be', ()=>{
 		,
 		base_,
 		base__set,
-	] = be_sig_triple_(()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_lock_memosig_triple_<number, 'test_ns', { custom: string }>(
+	] = be_lock_memosig_triple_<number, 'test_ns', { custom:string }>(
 		be_(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 */
 			const foobar$ =
-				memosig_<number, { custom: string }>(
-					()=>base_(ctx) + 1
-				).add(foobar$=>
-					memo_(()=>{
-						foobar$()
-						add_count++
-					}))
+				memosig_<number, { custom:string }>(
+					()=>base_(ctx) + 1,
+					[foobar$=>
+						memo_(()=>{
+							foobar$()
+							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))._, 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, 1)
-	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')
 	foobar__set(ctx, 5)
-	equal(foobar$_(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(foobar_(ctx), 5)
 	equal(add_count, 2)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 5)
+	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)
-	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
+	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(foobar_(ctx), 3)
-	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 3)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)(), 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 3)
 })
@@ -161,15 +167,16 @@ test('ns_be_lock_memosig_triple_', ()=>{
 		,
 		base_,
 		base__set,
-	] = be_sig_triple_(
-		()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		,
 		add_dep_,
 		add_dep__set
-	] = be_sig_triple_(()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		foobar$_,
 		foobar_,
@@ -182,28 +189,30 @@ test('ns_be_lock_memosig_triple_', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return base_(ctx) + 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))._, 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, 1)
 	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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 7)
@@ -234,27 +243,29 @@ test('id_be_lock_memosig_triple_', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return base_(ctx) + 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)._, 2)
+	equal(foobar$_(ctx)(), 2)
 	equal(foobar_(ctx), 2)
 	equal(add_count, 1)
-	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 2)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)(), 2)
 	equal(add_dep_(ctx), 3)
 	foobar__set(ctx, 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
-	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)(), 5)
 	equal(add_count, 2)
 	equal(add_dep_(ctx), 7)
 	base__set(ctx, 2)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(add_count, 2)
-	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)(), 5)
 	equal(add_dep_(ctx), 7)
 })
 test('ns_id_be_lock_memosig_triple_', ()=>{
@@ -264,15 +275,16 @@ test('ns_id_be_lock_memosig_triple_', ()=>{
 		,
 		base_,
 		base__set,
-	] = be_sig_triple_(
-		()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		,
 		add_dep_,
 		add_dep__set
-	] = be_sig_triple_(()=>1,
-		{ ns: 'test_ns' })
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
 	const [
 		foobar$_,
 		foobar_,
@@ -286,33 +298,35 @@ test('ns_id_be_lock_memosig_triple_', ()=>{
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			return base_(ctx) + 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))._, 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, 1)
-	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_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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
-	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)(), 5)
 	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_(ns_ctx__new(ctx__new(), ctx)), 5)
-	equal(foobar$_(ctx)._, 5)
+	equal(foobar$_(ctx)(), 5)
 	equal(foobar_(ctx), 5)
 	equal(add_count, 2)
-	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)(), 5)
 	equal(add_dep_(ctx), 7)
 })
 test.run()

package/all/be_memo_pair/index.d.ts

@@ -1,5 +1,5 @@
-import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, wide_ctx_T } from '../be_/index.js'
-import type { memo_T, sig_T } from '../rmemo/index.js'
+import type { Be, ctx__be_T, ctx__get_T, wide_ctx_T } from '../be_/index.js'
+import type { be_rmemo_add_def_T, memo_T, sig_T } from '../rmemo/index.js'
 export declare function be_memo_pair_<
 	val_T,
 	ns_T extends string = '',
@@ -13,7 +13,7 @@ export declare function be_memo_pair_<
 	ctx_T extends wide_ctx_T<ns_T> = wide_ctx_T<ns_T>,
 >(
 	val__new:(ctx:ctx_T, memo:sig_T<val_T, E>)=>val_T,
-	...config:be_config_arg_a_T<ns_T>
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_memo_pair_T<val_T, ns_T, E, ctx_T>
 export declare function ns_be_memo_pair_<
 	val_T,
@@ -23,6 +23,7 @@ export declare function ns_be_memo_pair_<
 >(
 	ns:ns_T,
 	val__new:(ctx:ctx_T, memo:sig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_memo_pair_T<val_T, ns_T, E, ctx_T>
 export declare function id_be_memo_pair_<
 	val_T,
@@ -31,6 +32,7 @@ export declare function id_be_memo_pair_<
 >(
 	id:string,
 	val__new:(ctx:ctx_T, memo:sig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, '', E, ctx_T>[]
 ):be_memo_pair_T<val_T, '', E, ctx_T>
 export declare function ns_id_be_memo_pair_<
 	val_T,
@@ -41,6 +43,7 @@ export declare function ns_id_be_memo_pair_<
 	ns:ns_T,
 	id:string,
 	val__new:(ctx:ctx_T, memo:sig_T<val_T, E>)=>val_T,
+	add_def_a1?:be_rmemo_add_def_T<val_T, ns_T, E, ctx_T>[]
 ):be_memo_pair_T<val_T, ns_T, E, ctx_T>
 export type be_memo_pair_T<
 	val_T,
@@ -50,8 +53,4 @@ export type be_memo_pair_T<
 > = [
 	ctx__be_T<memo_T<val_T, E>, ns_T, ctx_T>,
 	ctx__get_T<val_T, ns_T, ctx_T>,
-]&{
-	add<add_val_T>(
-		add_def:(ctx:ctx_T, sig:sig_T<val_T, E>)=>add_val_T
-	):be_memo_pair_T<val_T, ns_T, E, ctx_T>
-}
+]