ctx-core 3.3.3 → 4.0.0

package/README.md

@@ -1,2 +1,5 @@
 # ctx-core
 ctx-core core (ctx-core^2) libraries...used by @ctx-core/* libraries. The development monorepo has been moved to @ctx-core/dev
+
+## macropackage
+

package/all/all_union_a/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../add/index.js').all_union_a_T}all_union_a_T */
+/** @typedef {import('../add/index.js').all_union_a_T} */
 /**
  * @return {(a:all_union_a_T)=>all_union_a_T}
  * @see {@link https://stackoverflow.com/questions/60131681/make-sure-array-has-all-types-from-a-union/75418615#75418615}

package/all/andand_or/index.js

@@ -1,5 +1,5 @@
 import { andand } from '../andand/index.js'
-/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.js').andand_key_T} */
 /**
  * Returns `andand(obj, name_a) || or_fn(obj, val)`
  * @param {unknown|null}obj

package/all/andandfn/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.js').andand_key_T} */
 /**
  * Applies `&&` to a chain of property name or function with return value from `obj`.
  * @param {unknown}obj
@@ -24,7 +24,7 @@ export function andandfn(obj, ...name_a) {
 	return out_value
 }
 export { andandfn as andand__fn, }
-/** @typedef {import('../andand/index.d.ts').andand_key_T}andand_key_T */
+/** @typedef {import('../andand/index.d.ts').andand_key_T} */
 /**
  * Returns a function that calls `andand_(obj, ...name_a)`
  * @param {andand_key_T}name_a

package/all/arg_i0_a/index.js

@@ -1,5 +1,5 @@
 import { slice_arg_spread_a_ } from '../slice_arg_spread_a/index.js'
-/** @typedef {import('../slice_arg_spread_a_/index.js').slice_arg_spread_a__arg__T}slice_arg_spread_a__arg__T */
+/** @typedef {import('../slice_arg_spread_a_/index.js').slice_arg_spread_a__arg__T} */
 /**
  * Returns a function that calls fn passing only the first argument.
  * @param {slice_arg_spread_a__arg__T}fn

package/all/bad_credentials/index.js

@@ -1,6 +1,6 @@
 import { assign } from '../assign/index.js'
 import { HttpError } from '../http_error/index.js'
-/** @typedef {import('./index.d.ts').argument__bad_credentials_error_o_T}argument__bad_credentials_error_o_T */
+/** @typedef {import('./index.d.ts').argument__bad_credentials_error_o_T} */
 export const bad_credentials__default__message = 'Unauthorized'
 /**
  * @param {string}[message]

package/all/be/index.d.ts

@@ -1,5 +1,5 @@
-import type { be__val__T, Ctx } from '../be_/index.js'
+import type { be__val__new_T, Ctx } from '../be_/index.js'
 export declare function be<
 	Out extends NonNullable<unknown>
->(ctx:Ctx, key:string, val_:be__val__T<Out>):Out
+>(ctx:Ctx, val_:be__val__new_T<Out>):Out
 export { be as b, }

package/all/be/index.js

@@ -1,11 +1,10 @@
 import { be_ } from '../be_/index.js'
 /**
  * @param {import('../be_/index.js').Ctx}ctx
- * @param {string}key
- * @param {import('../be_/index.js').be__val__T}val_
+ * @param {import('../be_/index.js').be__val__new_T}val_
  * @returns {NonNullable<unknown>}
  */
-export function be(ctx, key, val_) {
-	return be_(key, val_)(ctx)
+export function be(ctx, val_) {
+	return be_(val_)(ctx)
 }
 export { be as b, }

package/all/be_/index.d.ts

@@ -1,19 +1,8 @@
 export declare const pending_symbol:unique symbol
 export declare function globalThis__be_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
-export declare function globalThis__be_<
-	Val,
-	ctx_T extends Ctx = Ctx
->(
-	id:string,
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
+>(val_:be__val__new_T<val_T, ctx_T>):Be<val_T, ctx_T>
 /**
  * Auto-memoization function for the Ctx.
  *
@@ -21,20 +10,13 @@ export declare function globalThis__be_<
  * otherwise it creates the value using the val_ factory function.
  */
 export declare function be_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
-export declare function be_<
-	Val,
+>(val_:be__val__new_T<val_T, ctx_T>):Be<val_T, ctx_T>
+export type be___T<
+	val_T,
 	ctx_T extends Ctx = Ctx
->(
-	id:string,
-	val_:be__val__T<Val, ctx_T>,
-	be__params?:be__params_T
-):Be<Val, ctx_T>
+> = typeof be_<val_T, ctx_T>
 export {
 	be_ as _be,
 	be_ as b_,
@@ -47,35 +29,35 @@ export declare function source__map_ctx_<
 	ctx_T extends Ctx = Ctx
 >(ctx:Ctx, is_source_:is_source__T):MapCtx
 export declare function be__set<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
-	be:Be<Val>,
+	be:Be<val_T>,
 	ctx:ctx_T,
-	val:Val
+	val:val_T
 ):void
 export declare function ctx__set<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
 	ctx:ctx_T,
-	be_OR_id:Be<Val>|string|symbol,
-	val:Val,
+	be_OR_id:Be<val_T>|string|symbol,
+	val:val_T,
 	is_source_?:is_source__T
 ):void
 export declare function be__delete<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
-	be:Be<Val>,
+	be:Be<val_T>,
 	ctx:ctx_T
 ):void
 export declare function ctx__delete<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
 >(
 	ctx:ctx_T,
-	be_OR_id:Be<Val>|string|symbol,
+	be_OR_id:Be<val_T>|string|symbol,
 	is_source_?:is_source__T
 ):void
 export declare function be__has_<
@@ -85,40 +67,40 @@ export declare function be__has__ctx_<
 	ctx_T extends Ctx = Ctx
 >(be_OR_id:Be<unknown>|string, ctx:ctx_T):MapCtx
 export declare function be__val_<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
->(be_OR_id:Be<Val>|string, ctx:ctx_T):Val|unknown|null
+>(be_OR_id:Be<val_T>|string, ctx:ctx_T):val_T|unknown|null
 export declare type MapCtx = Map<Be<unknown>|string|symbol, unknown>
 export interface NestedMapCtx extends Array<NestedMapCtx|MapCtx> {
 }
 export type Ctx = MapCtx|NestedMapCtx
 export declare type Be<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = ((ctx:ctx_T, params?:be_params_T)=>Val)&{
+> = ((ctx:ctx_T, params?:be_params_T)=>val_T)&{
 	id?:string
+}&{
+	config:(params:be__config_params_T)=>Be<val_T, ctx_T>
+}
+export type be__config_params_T = {
+	id?:string
+	expired_?:expired__T
+	is_source_?:is_source__T
 }
 export declare type be__return_T<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = Be<Val, ctx_T>
+> = Be<val_T, ctx_T>
 export declare type be_T<
-	Val,
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = Be<Val, ctx_T>
-export declare type be__val__T<
-	Val,
+> = Be<val_T, ctx_T>
+export declare type be__val__new_T<
+	val_T,
 	ctx_T extends Ctx = Ctx
-> = (ctx:ctx_T, be:Be<Val, ctx_T>, params?:be_params_T)=>Val
-export interface be__params_T {
-	is_source_?:is_source__T
-	expired_?:expired__T
-	be_?:typeof be_
-}
-export type be__opts_T = be__params_T
+> = (ctx:ctx_T, be:Be<val_T, ctx_T>, params?:be_params_T)=>val_T
 export interface be_params_T {
 	force?:boolean
 }
-export type be_opts_T = be_params_T
 export type is_source__T = (map_ctx:MapCtx, ctx:Ctx)=>boolean
 export type expired__T = (ctx:Ctx)=>boolean

package/all/be_/index.js

@@ -1,82 +1,46 @@
 import { globalThis__prop__ensure } from '../globalThis__prop__ensure/index.js'
 export * from './debug.js'
 let be_M_is_source_ = globalThis.be_M_is_source_ ||= new WeakMap()
-/** @typedef {import('./index.d.ts').Be}Be */
-/** @typedef {import('./index.d.ts').Ctx}Ctx */
-/** @typedef {import('./index.d.ts').MapCtx}MapCtx */
-/** @typedef {import('./index.d.ts').be__params_T}be__params_T */
-/** @typedef {import('./index.d.ts').be__val__T}be__val__T */
-/** @typedef {import('./index.d.ts').is_source__T}is_source__T */
+/** @typedef {import('./index.d.ts').Be} */
+/** @typedef {import('./index.d.ts').be_} */
+/** @typedef {import('./index.d.ts').Ctx} */
+/** @typedef {import('./index.d.ts').MapCtx} */
+/** @typedef {import('./index.d.ts').be__val__new_T} */
+/** @typedef {import('./index.d.ts').is_source__T} */
 /**
  * Auto-memoization function for the Ctx.
  * Memoized on globalThis to allow packages being loaded multiple times, which can happen during bundling.
  *
  * Returns a function to ensure that a member id_OR_val_ is defined on a ctx object,
  * otherwise it creates the value using the val__OR_be__params factory function.
- * @param {string|be__val__T}id_OR_val_
- * @param {be__val__T|be__params_T}[val__OR_be__params]
- * @param {be__params_T}[be__params]
+ * @param {be__val__new_T}val__new
  * @returns {Be}
  * @private
  */
-export function globalThis__be_(
-	id_OR_val_,
-	val__OR_be__params,
-	be__params
-) {
-	return globalThis__prop__ensure(
-		Symbol.for(id_OR_val_),
-		()=>be_(
-			id_OR_val_,
-			val__OR_be__params,
-			be__params))
-}
+export function globalThis__be_(val__new) {
+	return globalThis__prop__ensure(Symbol.for(val__new), ()=>be_(val__new))}
 /**
  * Auto-memoization function for the Ctx.
  *
  * Returns a function to ensure that a member id is defined on a Ctx,
  * otherwise it creates the value using the val_ factory function.
- * @param {string|be__val__T}id_OR_val__new
- * @param {be__val__T|be__params_T}[val__new_OR_be__params]
- * @param {be__params_T}[be__params]
+ * @param {be__val__new_T}val__new
  * @returns {Be}
  * @private
  */
-export function be_(
-	id_OR_val__new,
-	val__new_OR_be__params,
-	be__params
-) {
-	/** @type {string} */
-	let id
-	/** @type {be__val__T} */
-	let val__new
-	/** @type {is_source__T} */
-	let is_source_
+export function be_(val__new) {
 	/** @type {expired__T} */
 	let expired_
-	if (typeof id_OR_val__new === 'string') {
-		val__new = val__new_OR_be__params
-		id = id_OR_val__new
-	} else {
-		val__new = id_OR_val__new
-		be__params = val__new_OR_be__params
-	}
-	if (be__params) {
-		is_source_ = be__params.is_source_
-		expired_ = be__params.expired_
-	}
 	let be = (argv__ctx, params)=>{
 		be_.argv__debug?.(argv__ctx)
-		let saved__val = be__val_(be, argv__ctx)
 		if (
 			!params?.force
 			&& be__has_(be, argv__ctx)
 			&& !expired_?.(argv__ctx)
 		) {
-			return saved__val
+			return be__val_(be, argv__ctx)
 		}
-		let ctx = source__map_ctx_(argv__ctx, is_source_)
+		let ctx = source__map_ctx_(argv__ctx, be_M_is_source_.get(be))
 		be_.source__debug?.(ctx)
 		let pending = ctx.get(Symbol.for('pending'))
 		if (!pending) {
@@ -84,17 +48,21 @@ export function be_(
 			ctx.set(Symbol.for('pending'), pending)
 		}
 		be_.pending__debug?.(pending)
-		pending.set(be, id || be)
+		pending.set(be, be.id || be)
 		let val = val__new ? val__new(argv__ctx, be, params) : null
 		ctx.set(be, val)
-		if (id) {
-			ctx.set(id, val)
+		if (be.id) {
+			ctx.set(be.id, val)
 		}
 		pending.delete(be)
 		return val
 	}
-	be_M_is_source_.set(be, is_source_)
-	be.id = id
+	be.config = params=>{
+		be.id = params.id
+		expired_ = params.expired_
+		be_M_is_source_.set(be, params.is_source_)
+		return be
+	}
 	return be
 }
 export {

package/all/be_/index.test.ts

@@ -17,9 +17,9 @@ test('be_|Map', ()=>{
 	const ctx = ctx__new()
 	let incrementer_num = 0
 	const incrementer = ()=>++incrementer_num
-	const root_ = be_('root_', ()=>incrementer())
-	const child_ = be_('child_', ctx=>root_(ctx) + incrementer())
-	const child1_ = be_('child1_', ctx=>root_(ctx) + child_(ctx))
+	const root_ = be_(()=>incrementer()).config({ id: 'root_' })
+	const child_ = be_(ctx=>root_(ctx) + incrementer()).config({ id: 'child_' })
+	const child1_ = be_(ctx=>root_(ctx) + child_(ctx)).config({ id: 'child1_' })
 	equal(root_(ctx), 1)
 	equal(ctx.get('root_'), 1)
 	equal(child_(ctx), 3)
@@ -31,12 +31,12 @@ test('be_|simple array', ()=>{
 	const ctx0 = ctx__new()
 	const ctx1 = ctx__new()
 	const ctx = [ctx0, ctx1]
-	const root_ = be_('root_', ()=>1)
+	const root_ = be_(()=>1).config({ id: 'root_' })
 	equal(root_(ctx1), 1)
 	equal(root_(ctx), 1)
 	equal(ctx0.has(root_), false)
 	equal(ctx1.has(root_), true)
-	const child_ = be_('child_', ctx=>root_(ctx) + 1)
+	const child_ = be_(ctx=>root_(ctx) + 1).config({ id: 'child_' })
 	equal(child_(ctx), 2)
 	equal(ctx0.has(child_), true)
 	equal(ctx1.has(child_), false)
@@ -47,14 +47,14 @@ test('be_|nested array', ()=>{
 	const ctx2 = ctx__new()
 	const ctx3 = ctx__new()
 	const ctx = [[[ctx0], ctx1], [ctx2, ctx3]]
-	const root_ = be_('root_', ()=>1)
+	const root_ = be_(()=>1).config({ id: 'root_' })
 	equal(root_(ctx3), 1)
 	equal(root_(ctx), 1)
 	equal(ctx0.has(root_), false)
 	equal(ctx1.has(root_), false)
 	equal(ctx2.has(root_), false)
 	equal(ctx3.has(root_), true)
-	const child_ = be_('child_', ctx=>root_(ctx) + 1)
+	const child_ = be_(ctx=>root_(ctx) + 1).config({ id: 'child_' })
 	equal(child_(ctx), 2)
 	equal(ctx0.has(child_), true)
 	equal(ctx1.has(child_), false)
@@ -67,13 +67,12 @@ test('be_|is_source_', ()=>{
 	ctx1.set('matching', true)
 	const ctx = [ctx0, ctx1]
 	const be__ctx_a:Ctx[] = []
-	const root_ = be_('root_', ctx=>{
+	const root_ = be_(ctx=>{
 		be__ctx_a.push(ctx)
 		return 1
-	}, {
-		is_source_(map_ctx) {
-			return !!map_ctx.get('matching')
-		}
+	}).config({
+		is_source_: map_ctx=>!!map_ctx.get('matching'),
+		id: 'root_'
 	})
 	equal(root_(ctx), 1)
 	equal(be__ctx_a, [[ctx0, ctx1]])
@@ -82,7 +81,7 @@ test('be_|is_source_', ()=>{
 })
 test('be_|Ctx generic type', ()=>{
 	const valid_ctx = ctx__new() as test_ctx_T
-	const val_ = be_<boolean, test_ctx_T>('val_', ()=>true)
+	const val_ = be_<boolean, test_ctx_T>(()=>true).config({ id: 'val_' })
 	val_(valid_ctx)
 	// val_(ctx_()) // type error
 })
@@ -91,13 +90,14 @@ test('be_|Ctx|NestedMapCtx', ()=>{
 	const ctx1 = ctx__new()
 	ctx1.set('matching', true)
 	const ctx = [ctx0, ctx1]
-	const nested__ctx_ = be_<Ctx>('nested__ctx_', ctx=>[ctx])
+	const nested__ctx_ = be_<Ctx>(ctx=>[ctx]).config({ id: 'nested__ctx_' })
 	equal(nested__ctx_(ctx), [[ctx0, ctx1]])
 })
 test('be__set', ()=>{
 	const ctx0 = ctx__new()
-	const val_ = be_<number|undefined>('val_', ()=>undefined, {
-		is_source_: map_ctx=>map_ctx === ctx0
+	const val_ = be_<number|undefined>(()=>undefined).config({
+		is_source_: map_ctx=>map_ctx === ctx0,
+		id: 'val_'
 	})
 	be__set(val_, ctx0, 1)
 	equal(val_(ctx0), 1)
@@ -121,7 +121,7 @@ test('ctx__set', ()=>{
 })
 test('be__delete', ()=>{
 	const ctx0 = ctx__new()
-	const val_ = be_<boolean>('val_', ()=>true)
+	const val_ = be_<boolean>(()=>true).config({ id: 'val_' })
 	be__delete(val_, ctx0)
 	equal(ctx0.has(val_), false)
 	equal(ctx0.has('val_'), false)
@@ -193,8 +193,7 @@ test('ctx__delete|be', ()=>{
 	equal(ctx0.has(num_), false)
 	equal(ctx1.has(num_), false)
 	const is_source__num_ =
-		be_(()=>1,
-			{ is_source_: ctx=>!!ctx.get('ctx1') })
+		be_(()=>1).config({ is_source_: ctx=>!!ctx.get('ctx1') })
 	is_source__num_(nested__ctx)
 	equal(ctx0.has(is_source__num_), false)
 	equal(ctx1.has(is_source__num_), true)
@@ -236,7 +235,7 @@ test('be__has__ctx_', ()=>{
 })
 test('be__val_', ()=>{
 	const ctx = ctx__new()
-	const val_ = be_<boolean>('val_', ()=>true)
+	const val_ = be_<boolean>(()=>true).config({ id: 'val_' })
 	equal(val_(ctx), true)
 	equal(ctx.get(val_), true)
 	equal(be__val_(val_, ctx), true)

package/all/be_rmemo_pair/index.d.ts

@@ -0,0 +1,21 @@
+import type { Be, be__config_params_T, be__val__new_T, Ctx } from '../be_/index.js'
+import type { read_rmemo_T, rmemo_subscriber_T } from '../rmemo/index.js'
+export declare function be_rmemo_pair_<
+	val_T,
+	rmemo_T extends read_rmemo_T<val_T> = read_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+  ...subscriber_a:rmemo_subscriber_T<rmemo_T>[]
+):be_rmemo_pair_T<val_T, rmemo_T, ctx_T>
+export type be_rmemo_pair_T<
+	val_T,
+	rmemo_T extends read_rmemo_T<val_T> = read_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<rmemo_T, ctx_T>,
+	(ctx:ctx_T)=>val_T
+]&{
+	config:(params:be__config_params_T)=>be_rmemo_pair_T<val_T, rmemo_T, ctx_T>
+	oninit:(fn:(ctx:Ctx, rmemo:rmemo_T)=>unknown)=>be_rmemo_pair_T<val_T, rmemo_T, ctx_T>
+}

package/all/be_rmemo_pair/index.js

@@ -0,0 +1,25 @@
+import { be_ } from '../be_/index.js'
+import { rmemo_ } from '../rmemo/index.js'
+/** @typedef {import('../be_/index.d.ts').be__val__new_T} */
+/** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
+/** @typedef {import('./index.d.ts').be_rmemo_pair_T} */
+/**
+ * @param {be__val__new_T<unknown>}val__new
+ * @param {rmemo_subscriber_T[]}subscriber_a
+ * @returns {be_rmemo_pair_T}
+ * @private
+ */
+export function be_rmemo_pair_(val__new, ...subscriber_a) {
+	let oninit
+	const be_rmemo_pair = [
+		be_(ctx=>{
+			let rmemo = rmemo_(()=>val__new(ctx), ...subscriber_a)
+			oninit?.(ctx, rmemo)
+			return rmemo
+		}),
+		ctx=>be_rmemo_pair[0](ctx)._,
+	]
+  be_rmemo_pair.config = params=>(be_rmemo_pair[0].config(params), be_rmemo_pair)
+	be_rmemo_pair.oninit = _oninit=>(oninit = _oninit, be_rmemo_pair)
+	return be_rmemo_pair
+}

package/all/be_rmemo_pair/index.test.ts

@@ -0,0 +1,66 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { be_rsig_triple_ } from '../be_rsig_triple/index.js'
+import { ctx__new } from '../ctx/index.js'
+import type { read_rmemo_T, readwrite_rmemo_T } from '../rmemo/index.js'
+import { be_rmemo_pair_ } from './index.js'
+test('be_rmemo_pair_', ()=>{
+	const [
+		base$_,
+		base_,
+		base__set,
+	] = be_rsig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+	] = be_rmemo_pair_(ctx=>base_(ctx) + 1)
+	const ctx = ctx__new()
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	base__set(ctx, 2)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+})
+test('be_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
+	const ctx = ctx__new()
+	let subscriber_count = 0
+	const [
+		base$_,
+		base_,
+		base__set,
+	] = be_rsig_triple_(()=>1)
+		.config({ is_source_: map_ctx=>map_ctx === ctx })
+	const [
+		foobar$_,
+		foobar_,
+	] = be_rmemo_pair_<number, readwrite_rmemo_T<number>&{
+		custom:string
+	}>(ctx=>base_(ctx) + 1,
+		()=>subscriber_count++)
+		.config({
+			id: 'foobar',
+			is_source_: map_ctx=>map_ctx === ctx,
+		})
+		.oninit((_ctx, foobar$)=>{
+			if (Array.isArray(_ctx)) equal(_ctx[1], ctx)
+			else equal(_ctx, ctx)
+			foobar$.custom = 'custom-val'
+		})
+	equal(subscriber_count, 0)
+	equal(foobar$_([ctx__new(), ctx])._, 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal((ctx.get('foobar') as read_rmemo_T<number>)._, 2)
+	equal(foobar$_(ctx).custom, 'custom-val')
+	equal(subscriber_count, 1)
+	base__set(ctx, 2)
+	equal(foobar$_([ctx__new(), ctx])._, 3)
+	equal(foobar_([ctx__new(), ctx]), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal((ctx.get('foobar') as read_rmemo_T<number>)._, 3)
+	equal(foobar$_(ctx).custom, 'custom-val')
+	equal(subscriber_count, 1)
+})
+test.run()

package/all/be_rsig_triple/index.d.ts

@@ -0,0 +1,22 @@
+import type { Be, be__config_params_T, be__val__new_T, Ctx } from '../be_/index.js'
+import type { readwrite_rmemo_T, rmemo_subscriber_T } from '../rmemo/index.js'
+export declare function be_rsig_triple_<
+	val_T,
+	rsig_T extends readwrite_rmemo_T<val_T> = readwrite_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+	...subscriber_a:rmemo_subscriber_T<readwrite_rmemo_T<val_T>>[]
+):be_rsig_triple_T<val_T, rsig_T, ctx_T>
+export type be_rsig_triple_T<
+	val_T,
+	rsig_T extends readwrite_rmemo_T<val_T> = readwrite_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<rsig_T>,
+	(ctx:ctx_T)=>val_T,
+	(ctx:ctx_T, val:val_T)=>void
+]&{
+	config:(config:be__config_params_T)=>be_rsig_triple_T<val_T, rsig_T, ctx_T>
+	oninit:(fn:(ctx:Ctx, rsig:rsig_T)=>unknown)=>be_rsig_triple_T<val_T, rsig_T, ctx_T>
+}

package/all/be_rsig_triple/index.js

@@ -0,0 +1,28 @@
+import { be_ } from '../be_/index.js'
+import { rsig_ } from '../rmemo/index.js'
+/** @typedef {import('../be_/index.d.ts').be__val__new_T} */
+/** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
+/** @typedef {import('./index.d.ts').be_rsig_triple_T} */
+/**
+ * @param {be__val__new_T<unknown>}val__new
+ * @param {rmemo_subscriber_T[]}subscriber_a
+ * @returns {be_rsig_triple_T}
+ * @private
+ */
+export function be_rsig_triple_(val__new, ...subscriber_a) {
+	let oninit
+	const be_rsig_triple = [
+		be_(ctx=>{
+			let rsig = rsig_(val__new(ctx), ...subscriber_a)
+			oninit?.(ctx, rsig)
+			return rsig
+		}),
+		ctx=>be_rsig_triple[0](ctx)._,
+		(ctx, val)=>{
+			be_rsig_triple[0](ctx)._ = val
+		},
+	]
+	be_rsig_triple.config = params=>(be_rsig_triple[0].config(params), be_rsig_triple)
+	be_rsig_triple.oninit = _oninit=>(oninit = _oninit, be_rsig_triple)
+	return be_rsig_triple
+}