ctx-core 4.1.1 → 4.3.0

package/all/be_r_rmemo_pair/index.d.ts

@@ -0,0 +1,25 @@
+import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
+import type { r_rmemo_T, rmemo_def_T } from '../rmemo/index.js'
+export declare function be_r_rmemo_pair_<
+	val_T,
+	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(be: Be<_r_rmemo_T, ctx_T>):be_r_rmemo_pair_T<val_T, _r_rmemo_T, ctx_T>
+export declare function be_r_rmemo_pair_<
+	val_T,
+	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+	...subscriber_a_THEN_config:
+		|[...rmemo_def_T<val_T>[]]
+		|[...rmemo_def_T<val_T>[], config:be_config_T]
+):be_r_rmemo_pair_T<val_T, _r_rmemo_T, ctx_T>
+export type be_r_rmemo_pair_T<
+	val_T,
+	_r_rmemo_T extends r_rmemo_T<val_T> = r_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<_r_rmemo_T, ctx_T>,
+	(ctx:ctx_T)=>val_T
+]

package/all/{be_rmemo_pair → be_r_rmemo_pair}/index.js

@@ -1,17 +1,17 @@
 import { be_ } from '../be_/index.js'
-import { rmemo_ } from '../rmemo/index.js'
+import { r_rmemo_ } from '../rmemo/index.js'
 /** @typedef {import('../be_/index.d.ts').Be} */
 /** @typedef {import('../be_/index.d.ts').be__val__new_T} */
 /** @typedef {import('../be_/index.d.ts').be_config_T} */
 /** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_rmemo_pair_T} */
+/** @typedef {import('./index.d.ts').be_r_rmemo_pair_T} */
 /**
  * @param {Be|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
- * @returns {be_rmemo_pair_T}
+ * @returns {be_r_rmemo_pair_T}
  * @private
  */
-export function be_rmemo_pair_(
+export function be_r_rmemo_pair_(
 	be_OR_val__new,
 	...subscriber_a_THEN_config
 ) {
@@ -24,7 +24,7 @@ export function be_rmemo_pair_(
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
-				rmemo_(()=>be_OR_val__new(ctx), ...subscriber_a_THEN_config),
+				r_rmemo_(()=>be_OR_val__new(ctx), ...subscriber_a_THEN_config),
 			config)
 	return [
 		be,

package/all/{be_rmemo_pair → be_r_rmemo_pair}/index.test.ts

@@ -1,21 +1,21 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_ } from '../be_/index.js'
-import { be_rsig_triple_ } from '../be_rsig_triple/index.js'
+import { be_rw_rmemo_triple_ } from '../be_rw_rmemo_triple/index.js'
 import { ctx__new } from '../ctx/index.js'
-import type { read_rmemo_T, readwrite_rmemo_T } from '../rmemo/index.js'
-import { rmemo_ } from '../rmemo/index.js'
-import { be_rmemo_pair_ } from './index.js'
-test('be_rmemo_pair_', ()=>{
+import type { r_rmemo_T, rw_rmemo_T } from '../rmemo/index.js'
+import { r_rmemo_ } from '../rmemo/index.js'
+import { be_r_rmemo_pair_ } from './index.js'
+test('be_r_rmemo_pair_', ()=>{
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rsig_triple_(()=>1)
+	] = be_rw_rmemo_triple_(()=>1)
 	const [
 		foobar$_,
 		foobar_,
-	] = be_rmemo_pair_(ctx=>base_(ctx) + 1)
+	] = be_r_rmemo_pair_(ctx=>base_(ctx) + 1)
 	const ctx = ctx__new()
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
@@ -23,19 +23,19 @@ test('be_rmemo_pair_', ()=>{
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
 })
-test('be_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
+test('be_r_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rsig_triple_(()=>1,
+	] = be_rw_rmemo_triple_(()=>1,
 		{ is_source_: map_ctx=>map_ctx === ctx })
 	const [
 		foobar$_,
 		foobar_,
-	] = be_rmemo_pair_(ctx=>base_(ctx) + 1,
+	] = be_r_rmemo_pair_(ctx=>base_(ctx) + 1,
 		()=>subscriber_count++,
 		{
 			id: 'foobar',
@@ -46,34 +46,34 @@ test('be_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	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((ctx.get('foobar') as r_rmemo_T<number>)._, 2)
 	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((ctx.get('foobar') as r_rmemo_T<number>)._, 3)
 	equal(subscriber_count, 1)
 })
-test('be_rmemo_pair_|be', ()=>{
+test('be_r_rmemo_pair_|be', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		,
 		base_,
 		base__set,
-	] = be_rsig_triple_(()=>1,
+	] = be_rw_rmemo_triple_(()=>1,
 		{ is_source_: map_ctx=>map_ctx === ctx })
 	const [
 		foobar$_,
 		foobar_,
-	] = be_rmemo_pair_<number, custom_rmemo_T>(
+	] = be_r_rmemo_pair_<number, custom_r_rmemo_T>(
 		be_(_ctx=>{
-			const foobar$ = rmemo_(
+			const foobar$ = r_rmemo_(
 				()=>base_(ctx) + 1,
 				()=>subscriber_count++
-			) as custom_rmemo_T
+			) as custom_r_rmemo_T
 			if (Array.isArray(_ctx)) equal(_ctx[1], ctx)
 			else equal(_ctx, ctx)
 			foobar$.custom = 'custom-val'
@@ -87,7 +87,7 @@ test('be_rmemo_pair_|be', ()=>{
 	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((ctx.get('foobar') as r_rmemo_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 	base__set(ctx, 2)
@@ -95,9 +95,9 @@ test('be_rmemo_pair_|be', ()=>{
 	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((ctx.get('foobar') as r_rmemo_T<number>)._, 3)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 })
 test.run()
-type custom_rmemo_T = readwrite_rmemo_T<number>&{ custom:string }
+type custom_r_rmemo_T = rw_rmemo_T<number>&{ custom:string }

package/all/be_rw_rmemo_triple/index.d.ts

@@ -0,0 +1,26 @@
+import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
+import type { rw_rmemo_T, rmemo_def_T } from '../rmemo/index.js'
+export declare function be_rw_rmemo_triple_<
+	val_T,
+	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(be: Be<_rw_rmemo_T, ctx_T>):be_rw_rmemo_triple_T<val_T, _rw_rmemo_T, ctx_T>
+export declare function be_rw_rmemo_triple_<
+	val_T,
+	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:be__val__new_T<val_T>,
+	...subscriber_a_THEN_config:
+		|[...rmemo_def_T<val_T>[]]
+		|[...rmemo_def_T<val_T>[], config:be_config_T]
+):be_rw_rmemo_triple_T<val_T, _rw_rmemo_T, ctx_T>
+export type be_rw_rmemo_triple_T<
+	val_T,
+	_rw_rmemo_T extends rw_rmemo_T<val_T> = rw_rmemo_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<_rw_rmemo_T>,
+	(ctx:ctx_T)=>val_T,
+	(ctx:ctx_T, val:val_T)=>void
+]

package/all/{be_rsig_triple → be_rw_rmemo_triple}/index.js

@@ -1,18 +1,18 @@
 import { be_ } from '../be_/index.js'
-import { rsig_ } from '../rmemo/index.js'
+import { rw_rmemo_ } from '../rmemo/index.js'
 /** @typedef {import('../be_/index.d.ts').Be} */
 /** @typedef {import('../be_/index.d.ts').be__val__new_T} */
 /** @typedef {import('../be_/index.d.ts').be_config_T} */
-/** @typedef {import('../rmemo/index.d.ts').rsig_T} */
+/** @typedef {import('../rmemo/index.d.ts').rw_rmemo_T} */
 /** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_rsig_triple_T} */
+/** @typedef {import('./index.d.ts').be_rw_rmemo_triple_T} */
 /**
- * @param {Be<rsig_T>|be__val__new_T<unknown>}be_OR_val__new
+ * @param {Be<rw_rmemo_T>|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
- * @returns {be_rsig_triple_T}
+ * @returns {be_rw_rmemo_triple_T}
  * @private
  */
-export function be_rsig_triple_(
+export function be_rw_rmemo_triple_(
 	be_OR_val__new,
 	...subscriber_a_THEN_config
 ) {
@@ -20,11 +20,11 @@ export function be_rsig_triple_(
 		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
 			? subscriber_a_THEN_config.pop()
 			: undefined
-	/** @type {Be<rsig_T>} */
+	/** @type {Be<rw_rmemo_T>} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
-			: be_(ctx=>rsig_(be_OR_val__new(ctx), ...subscriber_a_THEN_config),
+			: be_(ctx=>rw_rmemo_(be_OR_val__new(ctx), ...subscriber_a_THEN_config),
 				config)
 	return [
 		be,

package/all/{be_rsig_triple → be_rw_rmemo_triple}/index.test.ts

@@ -2,14 +2,14 @@ import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { be_ } from '../be_/index.js'
 import { ctx__new } from '../ctx/index.js'
-import { type readwrite_rmemo_T, rsig_ } from '../rmemo/index.js'
-import { be_rsig_triple_ } from './index.js'
-test('be_rsig_triple_', ()=>{
+import { type rw_rmemo_T, rw_rmemo_ } from '../rmemo/index.js'
+import { be_rw_rmemo_triple_ } from './index.js'
+test('be_rw_rmemo_triple_', ()=>{
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rsig_triple_(()=>1)
+	] = be_rw_rmemo_triple_(()=>1)
 	const ctx = ctx__new()
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
@@ -17,14 +17,14 @@ test('be_rsig_triple_', ()=>{
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 })
-test('be_rsig_triple_|+id|+is_source_', ()=>{
+test('be_rw_rmemo_triple_|+id|+is_source_', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rsig_triple_(
+	] = be_rw_rmemo_triple_(
 		()=>1,
 		()=>subscriber_count++,
 		{ id: 'foobar', is_source_: map_ctx=>map_ctx === ctx },)
@@ -34,26 +34,26 @@ test('be_rsig_triple_|+id|+is_source_', ()=>{
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
 	equal(subscriber_count, 1)
-	equal((ctx.get('foobar') as readwrite_rmemo_T<number>)._, 1)
+	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 1)
 	foobar__set([ctx__new(), ctx], 2)
 	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 readwrite_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 2)
 	equal(subscriber_count, 1)
 })
-test('be_rsig_triple_|+be', ()=>{
+test('be_rw_rmemo_triple_|+be', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rsig_triple_<number, custom_rsig_T>(
+	] = be_rw_rmemo_triple_<number, custom_rw_rmemo_T>(
 		be_(()=>{
 			const foobar$ =
-				rsig_(1, ()=>subscriber_count++) as custom_rsig_T
+				rw_rmemo_(1, ()=>subscriber_count++) as custom_rw_rmemo_T
 			foobar$.custom = 'custom-val'
 			return foobar$
 		}, { id: 'foobar', is_source_: map_ctx=>map_ctx === ctx }))
@@ -63,16 +63,16 @@ test('be_rsig_triple_|+be', ()=>{
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)
 	equal(subscriber_count, 1)
-	equal((ctx.get('foobar') as readwrite_rmemo_T<number>)._, 1)
+	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 1)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	foobar__set([ctx__new(), ctx], 2)
 	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 readwrite_rmemo_T<number>)._, 2)
+	equal((ctx.get('foobar') as rw_rmemo_T<number>)._, 2)
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(subscriber_count, 1)
 })
 test.run()
-type custom_rsig_T = readwrite_rmemo_T<number>&{ custom:string }
+type custom_rw_rmemo_T = rw_rmemo_T<number>&{ custom:string }

package/all/index.d.ts

@@ -44,8 +44,8 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
-export * from './be_rmemo_pair/index.js'
-export * from './be_rsig_triple/index.js'
+export * from './be_r_rmemo_pair/index.js'
+export * from './be_rw_rmemo_triple/index.js'
 export * from './binary_sort_rank/index.js'
 export * from './bind_apply/index.js'
 export * from './bind_call/index.js'

package/all/index.js

@@ -44,8 +44,8 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
-export * from './be_rmemo_pair/index.js'
-export * from './be_rsig_triple/index.js'
+export * from './be_r_rmemo_pair/index.js'
+export * from './be_rw_rmemo_triple/index.js'
 export * from './binary_sort_rank/index.js'
 export * from './bind_apply/index.js'
 export * from './bind_call/index.js'

package/all/rmemo/index.d.ts

@@ -1,31 +1,27 @@
-export declare function rmemo_<val_T>(
+export declare function r_rmemo_<val_T>(
 	def:rmemo_def_T<val_T>,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
-):read_rmemo_T<val_T>
-export declare function rsig_<val_T>(
+):r_rmemo_T<val_T>
+export declare function rw_rmemo_<val_T>(
 	init_val:val_T,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
-):readwrite_rmemo_T<val_T>
-export type rmemo_T<val_T> = readwrite_rmemo_T<val_T>|read_rmemo_T<val_T>
-export type read_rmemo_T<val_T> = (()=>val_T)&read_rmemo_o_T<val_T>
-export type readwrite_rmemo_T<val_T> = ((val?:val_T)=>val_T)&rmemo_o_T<val_T>
-export type rsig_T<val_T> = readwrite_rmemo_T<val_T>
-export type rmemo_val_T<readwrite_rmemo_T> = readwrite_rmemo_T extends {
+):rw_rmemo_T<val_T>
+export type r_rmemo_T<val_T> = (()=>val_T)&r_rmemo_o_T<val_T>
+export type rw_rmemo_T<val_T> = ((val?:val_T)=>val_T)&rw_r_rmemo_o_T<val_T>
+export type rmemo_val_T<rw_rmemo_T> = rw_rmemo_T extends {
 		(): infer val_T
 	}
 	? val_T
 	: unknown
-export type rmemo_def_T<val_T> = (rmemo:readwrite_rmemo_T<val_T>)=>val_T
-export type rmemo_subscriber_T<val_T> = (rmemo:readwrite_rmemo_T<val_T>)=>unknown
-export type rmemo_o_T<val_T> = {
-	_:val_T
-	go():unknown
-	onset(val:val_T):unknown
-	refresh():val_T
-}&read_rmemo_o_T<val_T>
-export type read_rmemo_o_T<val_T> = {
+export type rmemo_def_T<val_T> = (rw_rmemo:rw_rmemo_T<val_T>)=>val_T
+export type rmemo_subscriber_T<val_T> = (rw_rmemo:rw_rmemo_T<val_T>)=>unknown
+export type r_rmemo_o_T<val_T> = {
 	readonly _:val_T
+	val:val_T
+	go():unknown
+}
+export type rw_r_rmemo_o_T<val_T> = {
+	_:val_T
+	val:val_T
 	go():unknown
-	onset(val:val_T):unknown
-	refresh():val_T
-}
+}

package/all/rmemo/index.js

@@ -1,85 +1,78 @@
-/** @typedef {import('./index.d.ts').rmemo_T} */
+/** @typedef {import('./index.d.ts').rmemo_def_T} */
+/** @typedef {import('./index.d.ts').r_rmemo_T} */
 /** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
-/** @type {WeakRef<rmemo_T>} */
-let cur_ref
+/** @type {WeakRef<r_rmemo_T>} */
+let cur_r
 /** @type {(()=>unknown)[]} */
 let queue = []
 /**
- * @param {(rmemo:rmemo_T<unknown>)=>unknown}_f
+ * @param {rmemo_def_T}rmemo_def
  * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
- * @returns {rmemo_T}
+ * @returns {r_rmemo_T}
  * @private
  */
-export function rmemo_(_f, ...subscriber_a) {
-	let rmemo = (...arg_a)=>arg_a.length ? rmemo._ = arg_a[0] : rmemo._
-	let _a = []
-	let _r = new WeakRef(()=>rmemo.refresh(_f(rmemo)))
-	_r.l = 0
-	rmemo._a = _a
-	rmemo._f = _f
-	rmemo._r = _r
-	rmemo._rS = new Set
-	rmemo.go = ()=>(rmemo(), rmemo)
-	rmemo.onset = ()=>0
-	Object.defineProperty(rmemo, '_', {
-		get() {
-			if (!_a.length) {
-				let prev_ref = cur_ref
-				cur_ref = _r
+export function r_rmemo_(rmemo_def, ...subscriber_a) {
+	let init
+	let r_rmemo = {
+		get _() {
+			if (!('val' in r_rmemo)) {
+				let prev_r = cur_r
+				cur_r = r_rmemo._r
 				try {
-					rmemo._ = _f(rmemo)
+					init()
 				} finally {
-					cur_ref = prev_ref
+					cur_r = prev_r
 				}
 			}
-			// allow self-referencing
-			if (cur_ref && cur_ref !== _r) {
-				cur_ref.l = cur_ref.l < _r.l + 1 ? _r.l + 1 : cur_ref.l
-				rmemo._rS.add(cur_ref)
+			if (cur_r) {
+				cur_r.l = cur_r.l < r_rmemo._r.l + 1 ? r_rmemo._r.l + 1 : cur_r.l
+				r_rmemo._rs.add(cur_r)
 			}
-			return _a[0]
+			return r_rmemo.val
 		},
-		set(val) {
-			if (!_a.length || val !== _a[0]) {
-				rmemo.refresh(val)
-			}
-		}
-	})
-	rmemo.refresh = val=>{
-		if (val !== _a[0]) {
-			_a[0] = val
-			rmemo.onset(val)
-			let run_queue = !queue[0]
-			for (let ref of rmemo._rS) {
-				if (!~queue.indexOf(ref)) queue.push(ref)
-			}
-			if (!rmemo._sa) {
-				rmemo._sa = subscriber_a.map(subscriber=>
-					rmemo_(()=>subscriber(rmemo)).go())
-			}
-			if (run_queue) {
-				// eslint-disable-next-line no-cond-assign
-				for (let ref; ref = queue.shift();) {
-					if (queue.some(_ref=>ref.l > _ref.l)) {
-						queue.push(ref)
-					} else {
-						(ref.deref() || rmemo._rS.delete)(ref)
+		set _(val) {
+			if (val !== r_rmemo.val) {
+				r_rmemo.val = val
+				r_rmemo._s?.(val)
+				let run_queue = !queue[0]
+				for (let r of r_rmemo._rs) {
+					if (!~queue.indexOf(r)) queue.push(r)
+				}
+				if (!r_rmemo._sa) {
+					r_rmemo._sa = subscriber_a.map(subscriber=>
+						r_rmemo_(()=>subscriber(r_rmemo)).go())
+				}
+				if (run_queue) {
+					// eslint-disable-next-line no-cond-assign
+					for (let r; r = queue.shift();) {
+						if (queue.some(queue_r=>r.l > queue_r.l)) {
+							queue.push(r)
+						} else {
+							(r.deref() || r_rmemo._rs.delete)(r)
+						}
 					}
 				}
 			}
-		}
+		},
+		go: ()=>(r_rmemo._, r_rmemo),
+		get: ()=>r_rmemo._,
+		set: val=>r_rmemo._ = val,
+		_rs: new Set,
 	}
-	return rmemo
+	init = ()=>r_rmemo._ = rmemo_def(r_rmemo)
+	r_rmemo._r = new WeakRef(init)
+	r_rmemo._r.l = 0
+	return r_rmemo
 }
 /**
  * @param {unknown}init_val
  * @param {rmemo_subscriber_T[]}subscriber_a
- * @returns {rmemo_T}
+ * @returns {r_rmemo_T}
  * @private
  */
-export function rsig_(init_val, ...subscriber_a) {
-	let rsig = rmemo_(_rsig=>_rsig._v, ...subscriber_a)
-	rsig.onset = val=>rsig._v = val
-	rsig._v = init_val
-	return rsig
+export function rw_rmemo_(init_val, ...subscriber_a) {
+	let rw_rmemo = r_rmemo_(_rw_rmemo=>_rw_rmemo._v, ...subscriber_a)
+	rw_rmemo._s = val=>rw_rmemo._v = val
+	rw_rmemo._v = init_val
+	return rw_rmemo
 }

package/all/rmemo/index.test.ts

@@ -2,84 +2,84 @@ import { deepStrictEqual } from 'node:assert'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { sleep } from '../sleep/index.js'
-import { rmemo_, rmemo_T, rsig_ } from './index.js'
-test('rmemo_|static value', ()=>{
+import { r_rmemo_, type r_rmemo_T, rw_rmemo_ } from './index.js'
+test('r_rmemo_|static value', ()=>{
 	let count = 0
-	let rmemo$ = rmemo_(rmemo=>{
+	const r_rmemo = r_rmemo_(()=>{
 		count++
 		return 'rmemo-value'
 	})
 	equal(count, 0)
-	equal(rmemo$(), 'rmemo-value')
+	equal(r_rmemo._, 'rmemo-value')
 	equal(count, 1)
-	equal(rmemo$(), 'rmemo-value')
+	equal(r_rmemo._, 'rmemo-value')
 	equal(count, 1)
 })
-test('rsig_', ()=>{
-	let rsig$ = rsig_('val0')
-	equal(rsig$(), 'val0')
-	rsig$('val1')
-	equal(rsig$(), 'val1')
+test('rw_rmemo_', ()=>{
+	const rw_rmemo = rw_rmemo_('val0')
+	equal(rw_rmemo._, 'val0')
+	rw_rmemo._ = 'val1'
+	equal(rw_rmemo._, 'val1')
 })
-test('rmemo_|def function|rmemo$ argument', ()=>{
-	let rsig$ = rsig_('val0')
-	let rmemo$:rmemo_T<string>&{custom?:string} = rmemo_<string>((_rmemo$:rmemo_T<string>&{custom?:string})=>
-		`${_rmemo$.custom}-${rsig$()}`)
-	rmemo$.custom = 'custom_val0'
-	equal(rmemo$(), 'custom_val0-val0')
-	rmemo$.custom = 'custom_val1'
-	equal(rmemo$(), 'custom_val0-val0')
-	rsig$('val1')
-	equal(rmemo$(), 'custom_val1-val1')
+test('r_rmemo_|def function|rmemo$ argument', ()=>{
+	const rw_rmemo = rw_rmemo_('val0')
+	const r_rmemo:r_rmemo_T<string>&{custom?:string} = r_rmemo_<string>((_rmemo$:r_rmemo_T<string>&{custom?:string})=>
+		`${_rmemo$.custom}-${rw_rmemo._}`)
+	r_rmemo.custom = 'custom_val0'
+	equal(r_rmemo._, 'custom_val0-val0')
+	r_rmemo.custom = 'custom_val1'
+	equal(r_rmemo._, 'custom_val0-val0')
+	rw_rmemo._ = 'val1'
+	equal(r_rmemo._, 'custom_val1-val1')
 })
-test('rsig_|async subsubscriber|case 1', async ()=>{
+test('rw_rmemo_|async subsubscriber|case 1', async ()=>{
 	let resolve:(user:{ id:string })=>void
-	let user0 = { id: 'id-0' }
-	let user1 = { id: 'id-1' }
-	let id$ = rsig_('id-0')
+	const user0 = { id: 'id-0' }
+	const user1 = { id: 'id-1' }
+	const id$ = rw_rmemo_('id-0')
 	let count = 0
-	let user$ = rsig_<{ id:string }|null>(
+	const user$ = rw_rmemo_<{ id:string }|null>(
 		null,
 		async (_user$)=>{
 			count++
-			id$()
-			let user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
-			_user$(user)
+			id$._
+			const user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
+			_user$._ = (user)
 		})
 	equal(count, 0)
-	equal(user$(), null)
+	equal(user$._, null)
 	equal(count, 1)
 	resolve!(user0)
 	await sleep(0)
 	equal(count, 1)
-	equal(user$(), user0)
+	equal(user$._, user0)
 	equal(count, 1)
-	id$('id-1')
+	id$._ = 'id-1'
 	equal(count, 2)
-	equal(user$(), user0)
+	equal(user$._, user0)
 	resolve!(user1)
 	await sleep(0)
 	equal(count, 2)
 })
-test('rsig_|async subsubscriber|case 2', async ()=>{
-	let a$ = rsig_(1)
-	let b$ = rsig_(2)
-	let sleepCycles = 5
-	let taskArgumentsCalls:number[][] = []
-	let sum$ = rsig_<null|number>(null,
+test('rw_rmemo_|async subsubscriber|case 2', async ()=>{
+	const a$ = rw_rmemo_(1)
+	const b$ = rw_rmemo_(2)
+	const sleepCycles = 5
+	const taskArgumentsCalls:number[][] = []
+	const sum$ = rw_rmemo_<null|number>(null,
 		async sum$=>{
-			taskArgumentsCalls.push([a$(), b$()])
+			taskArgumentsCalls.push([a$._, b$._])
 			for (let i = 0; i < sleepCycles; i++) {
 				await Promise.resolve()
 			}
-			sum$(a$() + b$())
+			sum$._ = a$._ + b$._
 		})
-	equal(sum$(), null)
+	equal(sum$._, null)
 	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
-	a$(10)
-	b$(20)
+	a$._ = 10
+	b$._ = 20
 	for (let i = 0; i < sleepCycles; i++) {
-		equal(sum$(), null)
+		equal(sum$._, null)
 		await Promise.resolve()
 		deepStrictEqual(taskArgumentsCalls, [
 			[1, 2],
@@ -87,107 +87,103 @@ test('rsig_|async subsubscriber|case 2', async ()=>{
 			[10, 20]
 		])
 	}
-	equal(sum$(), 30)
+	equal(sum$._, 30)
 	deepStrictEqual(taskArgumentsCalls, [
 		[1, 2],
 		[10, 2],
 		[10, 20]
 	])
 })
-test('rmemo_+rsig_|simple graph', ()=>{
-	let base$ = rsig_('base0')
-	let dep0$ = rmemo_(()=>base$() + '-dep0')
-	let dep1$ = rmemo_(()=>dep0$() + '-dep1')
-	let dep2$ = rmemo_(()=>dep1$() + '-dep2')
-	let dep3$ = rmemo_(()=>dep2$() + '-dep3')
-	let dep4$ = rmemo_(()=>dep3$() + '-dep4')
-	equal(dep4$(), 'base0-dep0-dep1-dep2-dep3-dep4')
-	equal(dep3$(), 'base0-dep0-dep1-dep2-dep3')
-	equal(dep2$(), 'base0-dep0-dep1-dep2')
-	equal(dep1$(), 'base0-dep0-dep1')
-	equal(dep0$(), 'base0-dep0')
-	equal(base$(), 'base0')
-	base$('base1')
-	equal(base$(), 'base1')
-	equal(dep0$(), 'base1-dep0')
-	equal(dep1$(), 'base1-dep0-dep1')
-	equal(dep2$(), 'base1-dep0-dep1-dep2')
-	equal(dep3$(), 'base1-dep0-dep1-dep2-dep3')
-	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
+test('r_rmemo_+rw_rmemo_|simple graph', ()=>{
+	const base$ = rw_rmemo_('base0')
+	const dep0$ = r_rmemo_(()=>base$._ + '-dep0')
+	const dep1$ = r_rmemo_(()=>dep0$._ + '-dep1')
+	const dep2$ = r_rmemo_(()=>dep1$._ + '-dep2')
+	const dep3$ = r_rmemo_(()=>dep2$._ + '-dep3')
+	const dep4$ = r_rmemo_(()=>dep3$._ + '-dep4')
+	equal(dep4$._, 'base0-dep0-dep1-dep2-dep3-dep4')
+	equal(dep3$._, 'base0-dep0-dep1-dep2-dep3')
+	equal(dep2$._, 'base0-dep0-dep1-dep2')
+	equal(dep1$._, 'base0-dep0-dep1')
+	equal(dep0$._, 'base0-dep0')
+	equal(base$._, 'base0')
+	base$._ = 'base1'
+	equal(base$._, 'base1')
+	equal(dep0$._, 'base1-dep0')
+	equal(dep1$._, 'base1-dep0-dep1')
+	equal(dep2$._, 'base1-dep0-dep1-dep2')
+	equal(dep3$._, 'base1-dep0-dep1-dep2-dep3')
+	equal(dep4$._, 'base1-dep0-dep1-dep2-dep3-dep4')
 })
 test('prevents diamond dependency problem 1', ()=>{
-	let store$ = rsig_(0)
-	let values:string[] = []
-	let a$ = rmemo_(()=>`a${store$()}`)
-	let b$ = rmemo_(()=>a$().replace('a', 'b'))
-	let c$ = rmemo_(()=>a$().replace('a', 'c'))
-	let d$ = rmemo_(()=>a$().replace('a', 'd'))
-	rmemo_(()=>`${b$()}${c$()}${d$()}`,
+	const store$ = rw_rmemo_(0)
+	const values:string[] = []
+	const a$ = r_rmemo_(()=>`a${store$._}`)
+	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
+	const c$ = r_rmemo_(()=>a$._.replace('a', 'c'))
+	const d$ = r_rmemo_(()=>a$._.replace('a', 'd'))
+	r_rmemo_(()=>`${b$._}${c$._}${d$._}`,
 		combined$=>
-			values.push(combined$())
+			values.push(combined$._)
 	).go()
 	deepStrictEqual(values, ['b0c0d0'])
-	store$(1)
-	store$(2)
+	store$._ = 1
+	store$._ = 2
 	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
 })
 test('prevents diamond dependency problem 2', ()=>{
-	let store$ = rsig_(0)
-	let values:string[] = []
-	let a$ = rmemo_(()=>`a${store$()}`)
-	let b$ = rmemo_(()=>a$().replace('a', 'b'))
-	let c$ = rmemo_(()=>b$().replace('b', 'c'))
-	let d$ = rmemo_(()=>c$().replace('c', 'd'))
-	let e$ = rmemo_(()=>d$().replace('d', 'e'))
-	rmemo_<string>(
-		()=>[a$(), e$()].join(''),
-		combined$=>values.push(combined$())
+	const store$ = rw_rmemo_(0)
+	const values:string[] = []
+	const a$ = r_rmemo_(()=>`a${store$._}`)
+	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
+	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
+	const d$ = r_rmemo_(()=>c$._.replace('c', 'd'))
+	const e$ = r_rmemo_(()=>d$._.replace('d', 'e'))
+	r_rmemo_<string>(
+		()=>[a$._, e$._].join(''),
+		$=>values.push($._)
 	).go()
 	deepStrictEqual(values, ['a0e0'])
-	store$(1)
+	store$._ = 1
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
 })
 test('prevents diamond dependency problem 3', ()=>{
-	let store$ = rsig_(0)
-	let values:string[] = []
-	let a$ = rmemo_(()=>`a${store$()}`)
-	let b$ = rmemo_(()=>a$().replace('a', 'b'))
-	let c$ = rmemo_(()=>b$().replace('b', 'c'))
-	let d$ = rmemo_(()=>c$().replace('c', 'd'))
-	rmemo_<string>(
-		()=>`${a$()}${b$()}${c$()}${d$()}`,
-		combined$=>values.push(combined$())
+	const store$ = rw_rmemo_(0)
+	const values:string[] = []
+	const a$ = r_rmemo_(()=>`a${store$._}`)
+	const b$ = r_rmemo_(()=>a$._.replace('a', 'b'))
+	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
+	const d$ = r_rmemo_(()=>c$._.replace('c', 'd'))
+	r_rmemo_<string>(
+		()=>`${a$._}${b$._}${c$._}${d$._}`,
+		combined$=>values.push(combined$._)
 	).go()
 	deepStrictEqual(values, ['a0b0c0d0'])
-	store$(1)
+	store$._ = 1
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
 })
 test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
-	let store1$ = rsig_(0)
-	let store2$ = rsig_(0)
-	let values:string[] = []
-	let fn =
-		(name:string)=>
-			(...v:(number|string)[])=>
-				`${name}${v.join('')}`
-	let a$ = rmemo_(()=>`a${store1$()}`)
-	let b$ = rmemo_(()=>`b${store2$()}`)
-	let c$ = rmemo_(()=>`c${a$()}${b$()}`)
-	let d$ = rmemo_(()=>`d${a$()}`)
-	let e$ = rmemo_(()=>`e${c$()}${d$()}`)
-	let f$ = rmemo_(()=>`f${e$()}`)
-	let g$ = rmemo_(()=>`g${f$()}`)
-	rmemo_(
-		()=>e$(),
-		combined1$=>values.push(combined1$())
+	const store1$ = rw_rmemo_(0)
+	const store2$ = rw_rmemo_(0)
+	const values:string[] = []
+	const a$ = r_rmemo_(()=>`a${store1$._}`)
+	const b$ = r_rmemo_(()=>`b${store2$._}`)
+	const c$ = r_rmemo_(()=>`c${a$._}${b$._}`)
+	const d$ = r_rmemo_(()=>`d${a$._}`)
+	const e$ = r_rmemo_(()=>`e${c$._}${d$._}`)
+	const f$ = r_rmemo_(()=>`f${e$._}`)
+	const g$ = r_rmemo_(()=>`g${f$._}`)
+	r_rmemo_(
+		()=>e$._,
+		combined1$=>values.push(combined1$._)
 	).go()
-	rmemo_(
-		()=>[e$(), g$()].join(''),
-		combined2$=>values.push(combined2$())
+	r_rmemo_(
+		()=>[e$._, g$._].join(''),
+		combined2$=>values.push(combined2$._)
 	).go()
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
-	store1$(1)
-	store2$(2)
+	store1$._ = 1
+	store2$._ = 2
 	deepStrictEqual(values, [
 		'eca0b0da0',
 		'eca0b0da0gfeca0b0da0',
@@ -199,66 +195,66 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 })
 test('prevents diamond dependency problem 5', ()=>{
 	let events = ''
-	let firstName$ = rsig_('John')
-	let lastName$ = rsig_('Doe')
-	let fullName$ = rmemo_(()=>{
+	const firstName$ = rw_rmemo_('John')
+	const lastName$ = rw_rmemo_('Doe')
+	const fullName$ = r_rmemo_(()=>{
 		events += 'full '
-		return `${firstName$()} ${lastName$()}`
+		return `${firstName$._} ${lastName$._}`
 	})
-	let isFirstShort$ = rmemo_(()=>{
+	const isFirstShort$ = r_rmemo_(()=>{
 		events += 'short '
-		return firstName$().length < 10
+		return firstName$._.length < 10
 	})
-	let displayName$ = rmemo_(
+	const displayName$ = r_rmemo_(
 		()=>{
 			events += 'display '
-			return isFirstShort$() ? fullName$() : firstName$()
+			return isFirstShort$._ ? fullName$._ : firstName$._
 		}
 	)
 	equal(events, '')
-	equal(displayName$(), 'John Doe')
+	equal(displayName$._, 'John Doe')
 	equal(events, 'display short full ')
-	firstName$('Benedict')
-	equal(displayName$(), 'Benedict Doe')
+	firstName$._ = 'Benedict'
+	equal(displayName$._, 'Benedict Doe')
 	equal(events, 'display short full short full display ')
-	firstName$('Montgomery')
-	equal(displayName$(), 'Montgomery')
+	firstName$._ = 'Montgomery'
+	equal(displayName$._, 'Montgomery')
 	equal(events, 'display short full short full display short full display ')
 })
 test('prevents diamond dependency problem 6', ()=>{
-	let store1$ = rsig_(0)
-	let store2$ = rsig_(0)
-	let values:string[] = []
-	let a$ = rmemo_(()=>`a${store1$()}`)
-	let b$ = rmemo_(()=>`b${store2$()}`)
-	let c$ = rmemo_(()=>b$().replace('b', 'c'))
-	rmemo_(
-		()=>`${a$()}${c$()}`,
-		combined$=>values.push(combined$())
+	const store1$ = rw_rmemo_(0)
+	const store2$ = rw_rmemo_(0)
+	const values:string[] = []
+	const a$ = r_rmemo_(()=>`a${store1$._}`)
+	const b$ = r_rmemo_(()=>`b${store2$._}`)
+	const c$ = r_rmemo_(()=>b$._.replace('b', 'c'))
+	r_rmemo_(
+		()=>`${a$._}${c$._}`,
+		combined$=>values.push(combined$._)
 	).go()
 	deepStrictEqual(values, ['a0c0'])
-	store1$(1)
+	store1$._ = 1
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
 })
 test('prevents dependency listeners from being out of order', ()=>{
-	let base$ = rsig_(0)
-	let a$ = rmemo_(()=>{
-		return `${base$()}a`
+	const base$ = rw_rmemo_(0)
+	const a$ = r_rmemo_(()=>{
+		return `${base$._}a`
 	})
-	let values:string[] = []
-	let b$ = rmemo_(()=>{
-		return `${a$()}b`
-	}, b$=>values.push(b$()))
-	equal(b$(), '0ab')
+	const values:string[] = []
+	const b$ = r_rmemo_(()=>{
+		return `${a$._}b`
+	}, b$=>values.push(b$._))
+	equal(b$._, '0ab')
 	deepStrictEqual(values, ['0ab'])
-	equal(a$(), '0a')
-	base$(1)
+	equal(a$._, '0a')
+	base$._ = 1
 	deepStrictEqual(values, ['0ab', '1ab'])
 })
 test('computes initial value when argument is undefined', ()=>{
-	let one$ = rsig_<string|undefined>(undefined)
-	let two$ = rmemo_(()=>!!one$())
-	equal(one$(), undefined)
-	equal(two$(), false)
+	const one$ = rw_rmemo_<string|undefined>(undefined)
+	const two$ = r_rmemo_(()=>!!one$._)
+	equal(one$._, undefined)
+	equal(two$._, false)
 })
 test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.1.1",
+  "version": "4.3.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -107,14 +107,14 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.13.1",
     "@size-limit/preset-small-lib": "^11.0.0",
-    "@types/node": "^20.9.2",
-    "@types/sinon": "^17.0.1",
+    "@types/node": "^20.9.3",
+    "@types/sinon": "^17.0.2",
     "c8": "^8.0.1",
     "check-dts": "^0.7.2",
     "sinon": "^17.0.1",
     "size-limit": "^11.0.0",
     "ts-node": "^10.9.1",
-    "tsx": "^4.1.4",
+    "tsx": "^4.2.0",
     "typescript": "next",
     "uvu": "^0.5.6"
   },
@@ -146,32 +146,32 @@
       "limit": "187 B"
     },
     {
-      "name": "rmemo_",
+      "name": "r_rmemo_",
       "import": {
-        "./rmemo": "{ rmemo_ }"
+        "./rmemo": "{ r_rmemo_ }"
       },
-      "limit": "344 B"
+      "limit": "289 B"
     },
     {
-      "name": "rmemo_ signal_",
+      "name": "r_rmemo_ signal_",
       "import": {
-        "./rmemo": "{ rsig_, rmemo_ }"
+        "./rmemo": "{ rw_rmemo_, r_rmemo_ }"
       },
-      "limit": "372 B"
+      "limit": "318 B"
     },
     {
-      "name": "rmemo_ signal_ be_ ctx_",
+      "name": "r_rmemo_ signal_ be_ ctx_",
       "import": {
-        "./rmemo": "{ rsig_, rmemo_, be_, ctx_ }"
+        "./rmemo": "{ rw_rmemo_, r_rmemo_, be_, ctx_ }"
       },
-      "limit": "532 B"
+      "limit": "475 B"
     },
     {
-      "name": "rmemo_ signal_ be_ ctx_ be_rmemo_pair_ be_rsig_triple_",
+      "name": "r_rmemo_ signal_ be_ ctx_ be_r_rmemo_pair_ be_rw_rmemo_triple_",
       "import": {
-        "./rmemo": "{ rsig_, rmemo_, be_, ctx_, be_rmemo_pair_, be_rsig_triple_ }"
+        "./rmemo": "{ rw_rmemo_, r_rmemo_, be_, ctx_, be_r_rmemo_pair_, be_rw_rmemo_triple_ }"
       },
-      "limit": "613 B"
+      "limit": "557 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -1,5 +1,5 @@
 export * from '../all/be_/index.js'
-export * from '../all/be_rmemo_pair/index.js'
-export * from '../all/be_rsig_triple/index.js'
+export * from '../all/be_r_rmemo_pair/index.js'
+export * from '../all/be_rw_rmemo_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'

package/rmemo/index.js

@@ -1,5 +1,5 @@
 export * from '../all/be_/index.js'
-export * from '../all/be_rmemo_pair/index.js'
-export * from '../all/be_rsig_triple/index.js'
+export * from '../all/be_r_rmemo_pair/index.js'
+export * from '../all/be_rw_rmemo_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'

package/all/be_rmemo_pair/index.d.ts

@@ -1,25 +0,0 @@
-import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { read_rmemo_T, rmemo_def_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
->(be: Be<rmemo_T, ctx_T>):be_rmemo_pair_T<val_T, rmemo_T, ctx_T>
-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_THEN_config:
-		|[...rmemo_def_T<val_T>[]]
-		|[...rmemo_def_T<val_T>[], config:be_config_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
-]

package/all/be_rsig_triple/index.d.ts

@@ -1,26 +0,0 @@
-import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { readwrite_rmemo_T, rmemo_def_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
->(be: Be<rsig_T, ctx_T>):be_rsig_triple_T<val_T, rsig_T, ctx_T>
-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_THEN_config:
-		|[...rmemo_def_T<val_T>[]]
-		|[...rmemo_def_T<val_T>[], config:be_config_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
-]