ctx-core 4.0.0 → 4.1.1

package/all/be_/index.d.ts

@@ -6,36 +6,23 @@ export declare function globalThis__be_<
 /**
  * Auto-memoization function for the Ctx.
  *
- * Returns a function to ensure that a member id is defined on a ctx object,
- * otherwise it creates the value using the val_ factory function.
+ * Returns a function to ensure that a member id is defined on a Ctx,
+ * otherwise it caches & uses the return value of val__new.
  */
 export declare function be_<
 	val_T,
 	ctx_T extends Ctx = Ctx
->(val_:be__val__new_T<val_T, ctx_T>):Be<val_T, ctx_T>
+>(val__new:be__val__new_T<val_T, ctx_T>, config?:be_config_T):Be<val_T, ctx_T>
 export type be___T<
 	val_T,
 	ctx_T extends Ctx = Ctx
 > = typeof be_<val_T, ctx_T>
-export {
-	be_ as _be,
-	be_ as b_,
-	be_ as _b,
-}
 export declare function be__is_source_<
 	ctx_T extends Ctx = Ctx
 >(be:Be<unknown>):(map_ctx:MapCtx, ctx:ctx_T)=>boolean
 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_T,
-	ctx_T extends Ctx = Ctx
->(
-	be:Be<val_T>,
-	ctx:ctx_T,
-	val:val_T
-):void
+>(ctx:ctx_T, is_source_:is_source__T):MapCtx
 export declare function ctx__set<
 	val_T,
 	ctx_T extends Ctx = Ctx
@@ -45,13 +32,6 @@ export declare function ctx__set<
 	val:val_T,
 	is_source_?:is_source__T
 ):void
-export declare function be__delete<
-	val_T,
-	ctx_T extends Ctx = Ctx
->(
-	be:Be<val_T>,
-	ctx:ctx_T
-):void
 export declare function ctx__delete<
 	val_T,
 	ctx_T extends Ctx = Ctx
@@ -63,28 +43,25 @@ export declare function ctx__delete<
 export declare function be__has_<
 	ctx_T extends Ctx = Ctx
 >(be_OR_id:Be<unknown>|string, ctx:ctx_T):boolean
-export declare function be__has__ctx_<
+export declare function be__ctx_<
 	ctx_T extends Ctx = Ctx
 >(be_OR_id:Be<unknown>|string, ctx:ctx_T):MapCtx
 export declare function be__val_<
 	val_T,
 	ctx_T extends Ctx = Ctx
 >(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 MapCtx = Map<Be<unknown>|string|symbol, unknown>&{ is_ctx: true }
+export type NestedMapCtx = Array<NestedMapCtx|MapCtx>
 export type Ctx = MapCtx|NestedMapCtx
 export declare type Be<
 	val_T,
 	ctx_T extends Ctx = Ctx
-> = ((ctx:ctx_T, params?:be_params_T)=>val_T)&{
+> = ((ctx:ctx_T)=>val_T)&{
+	is_be: true
 	id?:string
-}&{
-	config:(params:be__config_params_T)=>Be<val_T, ctx_T>
 }
-export type be__config_params_T = {
+export type be_config_T = {
 	id?:string
-	expired_?:expired__T
 	is_source_?:is_source__T
 }
 export declare type be__return_T<
@@ -98,9 +75,6 @@ export declare type be_T<
 export declare type be__val__new_T<
 	val_T,
 	ctx_T extends Ctx = Ctx
-> = (ctx:ctx_T, be:Be<val_T, ctx_T>, params?:be_params_T)=>val_T
-export interface be_params_T {
-	force?:boolean
-}
+> = (ctx:ctx_T, be:Be<val_T, ctx_T>)=>val_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,8 +1,7 @@
 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} */
 /** @typedef {import('./index.d.ts').be_} */
+/** @typedef {import('./index.d.ts').be_config_T} */
 /** @typedef {import('./index.d.ts').Ctx} */
 /** @typedef {import('./index.d.ts').MapCtx} */
 /** @typedef {import('./index.d.ts').be__val__new_T} */
@@ -12,82 +11,49 @@ let be_M_is_source_ = globalThis.be_M_is_source_ ||= new WeakMap()
  * 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.
+ * otherwise it caches & uses the return value of val__new.
  * @param {be__val__new_T}val__new
  * @returns {Be}
  * @private
  */
 export function globalThis__be_(val__new) {
-	return globalThis__prop__ensure(Symbol.for(val__new), ()=>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.
+ * otherwise it caches & uses the return value of val__new.
  * @param {be__val__new_T}val__new
+ * @param {be_config_T}[config]
  * @returns {Be}
  * @private
  */
-export function be_(val__new) {
-	/** @type {expired__T} */
-	let expired_
-	let be = (argv__ctx, params)=>{
-		be_.argv__debug?.(argv__ctx)
-		if (
-			!params?.force
-			&& be__has_(be, argv__ctx)
-			&& !expired_?.(argv__ctx)
-		) {
-			return be__val_(be, argv__ctx)
+export function be_(val__new, config) {
+	let be = argv__ctx=>{
+		let flat__argv__ctx = Array.isArray(argv__ctx) && argv__ctx.flat(Infinity)
+		let be__ctx =
+      flat__argv__ctx
+	      ? flat__argv__ctx.find(ctx=>ctx.has(be))
+	      : argv__ctx.has(be) && argv__ctx
+		if (!be__ctx) {
+			be__ctx =
+				flat__argv__ctx
+					? flat__argv__ctx.find(ctx=>!be.is_source_ || be.is_source_(ctx, argv__ctx))
+					: (!be.is_source_ || be.is_source_(argv__ctx, argv__ctx)) && argv__ctx
+			// circular dependency state
+			// if val__new calls this be before returning, Symbol('cir') will be the value of this be
+			// 'cir' is used instead of 'circular' to reduce the payload by a few bytes
+			be__ctx.set(be, Symbol('cir'))
+			be__ctx.set(be, val__new(argv__ctx, be))
+			if (be.id) be__ctx.set(be.id, be__ctx.get(be))
 		}
-		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) {
-			pending = new Map
-			ctx.set(Symbol.for('pending'), pending)
-		}
-		be_.pending__debug?.(pending)
-		pending.set(be, be.id || be)
-		let val = val__new ? val__new(argv__ctx, be, params) : null
-		ctx.set(be, val)
-		if (be.id) {
-			ctx.set(be.id, val)
-		}
-		pending.delete(be)
-		return val
-	}
-	be.config = params=>{
-		be.id = params.id
-		expired_ = params.expired_
-		be_M_is_source_.set(be, params.is_source_)
-		return be
+		return be__ctx.get(be)
 	}
+	be.id = config?.id
+	be.is_source_ = config?.is_source_
+	be.is_be = true
 	return be
 }
-export {
-	be_ as _be,
-	be_ as b_,
-	be_ as _b,
-}
-/**
- * @param {Be}be
- * @returns {is_source__T}
- * @private
- */
-export function be__is_source__(be) {
-	return be_M_is_source_.get(be)
-}
-/**
- * @param {Be}be
- * @param {Ctx}ctx
- * @param {unknown}val
- * @returns {unknown}
- * @private
- */
-export function be__set(be, ctx, val) {
-	ctx__set(ctx, be, val, be__is_source__(be))
-}
 /**
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
@@ -100,7 +66,7 @@ export function ctx__set(
 	ctx,
 	be_OR_id,
 	val,
-	is_source_
+	is_source_ = be_OR_id.is_source_
 ) {
 	let source__map_ctx = source__map_ctx_(ctx, is_source_)
 	if (source__map_ctx) {
@@ -111,18 +77,9 @@ export function ctx__set(
 		}
 	}
 }
-/**
- * @param {Be}be
- * @param {Ctx}ctx
- * @private
- */
-export function be__delete(be, ctx) {
-	ctx__delete(ctx, be)
-}
 /**
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
- * @param {is_source__T}[is_source_]
  */
 export function ctx__delete(
 	ctx,
@@ -149,7 +106,7 @@ export function ctx__delete(
  * @private
  */
 export function be__has_(be_or_id, argv__ctx) {
-	return Boolean(be__has__ctx_(be_or_id, argv__ctx))
+	return Boolean(be__ctx_(be_or_id, argv__ctx))
 }
 /**
  * @param {Be|string}be_or_id
@@ -157,17 +114,17 @@ export function be__has_(be_or_id, argv__ctx) {
  * @returns {MapCtx}
  * @private
  */
-export function be__has__ctx_(be_or_id, argv__ctx) {
+export function be__ctx_(be_or_id, argv__ctx) {
 	if (Array.isArray(argv__ctx)) {
-		for (let i = 0; i < argv__ctx.length; i++) {
-			const be__has__ctx = be__has__ctx_(be_or_id, argv__ctx[i])
-			if (be__has__ctx) return be__has__ctx
+		for (let ctx of argv__ctx) {
+			let be__ctx = be__ctx_(be_or_id, ctx)
+			if (be__ctx) return be__ctx
 		}
-		return null
 	} else {
-		return argv__ctx.has(be_or_id) ? argv__ctx : null
+		if (argv__ctx.has(be_or_id)) return argv__ctx
 	}
 }
+export { be__ctx_ as be__has__ctx_ }
 /**
  * @param {Be|string}be_or_id
  * @param {Ctx}argv__ctx
@@ -175,30 +132,22 @@ export function be__has__ctx_(be_or_id, argv__ctx) {
  * @private
  */
 export function be__val_(be_or_id, argv__ctx) {
-	if (Array.isArray(argv__ctx)) {
-		for (let i = 0; i < argv__ctx.length; i++) {
-			let ctx = argv__ctx[i]
-			const be__has__ctx = be__has__ctx_(be_or_id, ctx)
-			if (be__has__ctx) return be__has__ctx.get(be_or_id)
-		}
-	} else {
-		return argv__ctx.get(be_or_id)
-	}
+	let be__ctx = be__ctx_(be_or_id, argv__ctx)
+	if (be__ctx) return be__ctx.get(be_or_id)
 }
 /**
- * @param {Ctx}ctx
+ * @param {Ctx}argv__ctx
  * @param {is_source__T}is_source_
  * @returns {unknown}
  * @private
  */
-export function source__map_ctx_(ctx, is_source_) {
-	if (Array.isArray(ctx)) {
-		for (let i = 0; i < ctx.length; i++) {
-			let i_ctx = ctx[i]
-			let source__map_ctx = source__map_ctx_(i_ctx, is_source_)
+export function source__map_ctx_(argv__ctx, is_source_) {
+	if (Array.isArray(argv__ctx)) {
+		for (let ctx of argv__ctx) {
+			let source__map_ctx = source__map_ctx_(ctx, is_source_)
 			if (source__map_ctx) return source__map_ctx
 		}
-	} else if (!is_source_ || is_source_(/** @type {MapCtx} */ctx, ctx)) {
-		return ctx
+	} else if (!is_source_ || is_source_(/** @type {MapCtx} */argv__ctx, argv__ctx)) {
+		return argv__ctx
 	}
 }

package/all/be_/index.test.ts

@@ -1,11 +1,10 @@
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import {
+	type Be,
 	be_,
-	be__delete,
+	be__ctx_,
 	be__has_,
-	be__has__ctx_,
-	be__set,
 	be__val_,
 	type Ctx,
 	ctx__delete,
@@ -13,13 +12,14 @@ import {
 	type MapCtx
 } from '../be_/index.js'
 import { ctx__new } from '../ctx/index.js'
+
 test('be_|Map', ()=>{
 	const ctx = ctx__new()
 	let incrementer_num = 0
 	const incrementer = ()=>++incrementer_num
-	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_' })
+	const root_ = be_(()=>incrementer(), { id: 'root_' })
+	const child_ = be_(ctx=>root_(ctx) + incrementer(), { id: 'child_' })
+	const child1_ = be_(ctx=>root_(ctx) + child_(ctx), { 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_(()=>1).config({ id: 'root_' })
+	const root_ = be_(()=>1, { id: 'root_' })
 	equal(root_(ctx1), 1)
 	equal(root_(ctx), 1)
 	equal(ctx0.has(root_), false)
 	equal(ctx1.has(root_), true)
-	const child_ = be_(ctx=>root_(ctx) + 1).config({ id: 'child_' })
+	const child_ = be_(ctx=>root_(ctx) + 1, { 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_(()=>1).config({ id: 'root_' })
+	const root_ = be_(()=>1, { 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_(ctx=>root_(ctx) + 1).config({ id: 'child_' })
+	const child_ = be_(ctx=>root_(ctx) + 1, { id: 'child_' })
 	equal(child_(ctx), 2)
 	equal(ctx0.has(child_), true)
 	equal(ctx1.has(child_), false)
@@ -70,7 +70,7 @@ test('be_|is_source_', ()=>{
 	const root_ = be_(ctx=>{
 		be__ctx_a.push(ctx)
 		return 1
-	}).config({
+	}, {
 		is_source_: map_ctx=>!!map_ctx.get('matching'),
 		id: 'root_'
 	})
@@ -81,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>(()=>true).config({ id: 'val_' })
+	const val_ = be_<boolean, test_ctx_T>(()=>true, { id: 'val_' })
 	val_(valid_ctx)
 	// val_(ctx_()) // type error
 })
@@ -90,23 +90,15 @@ test('be_|Ctx|NestedMapCtx', ()=>{
 	const ctx1 = ctx__new()
 	ctx1.set('matching', true)
 	const ctx = [ctx0, ctx1]
-	const nested__ctx_ = be_<Ctx>(ctx=>[ctx]).config({ id: 'nested__ctx_' })
+	const nested__ctx_ = be_<Ctx>(ctx=>[ctx], { id: 'nested__ctx_' })
 	equal(nested__ctx_(ctx), [[ctx0, ctx1]])
 })
-test('be__set', ()=>{
-	const ctx0 = ctx__new()
-	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)
-	const ctx1 = ctx__new()
-	const ctx_a = [ctx1, ctx0]
-	be__set(val_, ctx_a, 2)
-	equal(val_(ctx0), 2)
-	equal(val_(ctx_a), 2)
-	equal(ctx1.has(val_), false)
+test('be_|circular dependency', ()=>{
+	const be0:Be<symbol> = be_(ctx=>be1(ctx))
+	const be1:Be<symbol> = be_(ctx=>be0(ctx))
+	const ctx = ctx__new()
+	equal(String(be0(ctx)), 'Symbol(cir)')
+	equal(String(be1(ctx)), 'Symbol(cir)')
 })
 test('ctx__set', ()=>{
 	const ctx0 = ctx__new()
@@ -119,31 +111,6 @@ test('ctx__set', ()=>{
 	equal(ctx0.get('key'), 2)
 	equal(ctx1.has('key'), false)
 })
-test('be__delete', ()=>{
-	const ctx0 = ctx__new()
-	const val_ = be_<boolean>(()=>true).config({ id: 'val_' })
-	be__delete(val_, ctx0)
-	equal(ctx0.has(val_), false)
-	equal(ctx0.has('val_'), false)
-	equal(val_(ctx0), true)
-	equal(ctx0.get(val_), true)
-	equal(ctx0.get('val_'), true)
-	be__delete(val_, ctx0)
-	equal(ctx0.has(val_), false)
-	equal(ctx0.has('val_'), false)
-	const ctx1 = ctx__new()
-	const nested__ctx = [ctx0, ctx1]
-	equal(val_(ctx0), true)
-	equal(val_(ctx1), true)
-	equal(val_(nested__ctx), true)
-	equal(ctx0.get('val_'), true)
-	equal(ctx1.get('val_'), true)
-	be__delete(val_, nested__ctx)
-	equal(ctx0.has(val_), false)
-	equal(ctx0.has('val_'), false)
-	equal(ctx1.has(val_), false)
-	equal(ctx1.has('val_'), false)
-})
 test('ctx__delete|id', ()=>{
 	const ctx0 = ctx__new()
 	ctx__delete(ctx0, 'key')
@@ -193,7 +160,7 @@ test('ctx__delete|be', ()=>{
 	equal(ctx0.has(num_), false)
 	equal(ctx1.has(num_), false)
 	const is_source__num_ =
-		be_(()=>1).config({ is_source_: ctx=>!!ctx.get('ctx1') })
+		be_(()=>1, { 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)
@@ -220,26 +187,26 @@ test('be__has_', ()=>{
 	ctx1.set('key', true)
 	equal(be__has_('key', nested__ctx), true)
 })
-test('be__has__ctx_', ()=>{
+test('be__ctx_', ()=>{
 	const ctx0 = ctx__new()
 	ctx__delete(ctx0, 'key')
-	equal(be__has__ctx_('key', ctx0), null)
+	equal(be__ctx_('key', ctx0), undefined)
 	ctx0.set('key', true)
-	equal(be__has__ctx_('key', ctx0), ctx0)
+	equal(be__ctx_('key', ctx0), ctx0)
 	ctx__delete(ctx0, 'key')
-	equal(be__has__ctx_('key', ctx0), null)
+	equal(be__ctx_('key', ctx0), undefined)
 	const ctx1 = ctx__new()
 	const nested__ctx = [ctx0, ctx1]
 	ctx1.set('key', true)
-	equal(be__has__ctx_('key', nested__ctx), ctx1)
+	equal(be__ctx_('key', nested__ctx), ctx1)
 })
 test('be__val_', ()=>{
 	const ctx = ctx__new()
-	const val_ = be_<boolean>(()=>true).config({ id: 'val_' })
+	const val_ = be_<boolean>(()=>true, { id: 'val_' })
 	equal(val_(ctx), true)
 	equal(ctx.get(val_), true)
 	equal(be__val_(val_, ctx), true)
-	be__set(val_, ctx, false)
+	ctx__set(ctx, val_, false)
 	equal(val_(ctx), false)
 	equal(be__val_(val_, ctx), false)
 })

package/all/be_rmemo_pair/index.d.ts

@@ -1,12 +1,19 @@
-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'
+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:rmemo_subscriber_T<rmemo_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,
@@ -15,7 +22,4 @@ export type be_rmemo_pair_T<
 > = [
 	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

@@ -1,25 +1,36 @@
 import { be_ } from '../be_/index.js'
 import { 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} */
 /**
- * @param {be__val__new_T<unknown>}val__new
- * @param {rmemo_subscriber_T[]}subscriber_a
+ * @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}
  * @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)._,
+export function be_rmemo_pair_(
+	be_OR_val__new,
+	...subscriber_a_THEN_config
+) {
+	let config =
+		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
+			? subscriber_a_THEN_config.pop()
+			: undefined
+	/** @type {Be} */
+	let be =
+		be_OR_val__new.is_be
+			? be_OR_val__new
+			: be_(ctx=>
+				rmemo_(()=>be_OR_val__new(ctx), ...subscriber_a_THEN_config),
+			config)
+	return [
+		be,
+		ctx=>be(ctx)._,
+		(ctx, val)=>{
+			be(ctx)._ = val
+		},
 	]
-  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

@@ -1,12 +1,14 @@
 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 { 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_', ()=>{
 	const [
-		base$_,
+		,
 		base_,
 		base__set,
 	] = be_rsig_triple_(()=>1)
@@ -25,27 +27,61 @@ 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 })
+	] = be_rsig_triple_(()=>1,
+		{ 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({
+	] = be_rmemo_pair_(ctx=>base_(ctx) + 1,
+		()=>subscriber_count++,
+		{
 			id: 'foobar',
 			is_source_: map_ctx=>map_ctx === ctx,
 		})
-		.oninit((_ctx, foobar$)=>{
+	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(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(subscriber_count, 1)
+})
+test('be_rmemo_pair_|be', ()=>{
+	const ctx = ctx__new()
+	let subscriber_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_rsig_triple_(()=>1,
+		{ is_source_: map_ctx=>map_ctx === ctx })
+	const [
+		foobar$_,
+		foobar_,
+	] = be_rmemo_pair_<number, custom_rmemo_T>(
+		be_(_ctx=>{
+			const foobar$ = rmemo_(
+				()=>base_(ctx) + 1,
+				()=>subscriber_count++
+			) as custom_rmemo_T
 			if (Array.isArray(_ctx)) equal(_ctx[1], ctx)
 			else equal(_ctx, ctx)
 			foobar$.custom = 'custom-val'
-		})
+			return foobar$
+		}, {
+			id: 'foobar',
+			is_source_: map_ctx=>map_ctx === ctx,
+		}))
 	equal(subscriber_count, 0)
 	equal(foobar$_([ctx__new(), ctx])._, 2)
 	equal(foobar_([ctx__new(), ctx]), 2)
@@ -64,3 +100,4 @@ test('be_rmemo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	equal(subscriber_count, 1)
 })
 test.run()
+type custom_rmemo_T = readwrite_rmemo_T<number>&{ custom:string }

package/all/be_rsig_triple/index.d.ts

@@ -1,12 +1,19 @@
-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'
+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:rmemo_subscriber_T<readwrite_rmemo_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,
@@ -16,7 +23,4 @@ export type be_rsig_triple_T<
 	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

@@ -1,28 +1,36 @@
 import { be_ } from '../be_/index.js'
 import { rsig_ } 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').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
+ * @param {Be<rsig_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}
  * @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)._,
+export function be_rsig_triple_(
+	be_OR_val__new,
+	...subscriber_a_THEN_config
+) {
+	let config =
+		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
+			? subscriber_a_THEN_config.pop()
+			: undefined
+	/** @type {Be<rsig_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),
+				config)
+	return [
+		be,
+		ctx=>be(ctx)._,
 		(ctx, val)=>{
-			be_rsig_triple[0](ctx)._ = val
+			be(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
 }

package/all/be_rsig_triple/index.test.ts

@@ -1,7 +1,8 @@
 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 } from '../rmemo/index.js'
+import { type readwrite_rmemo_T, rsig_ } from '../rmemo/index.js'
 import { be_rsig_triple_ } from './index.js'
 test('be_rsig_triple_', ()=>{
 	const [
@@ -16,22 +17,46 @@ test('be_rsig_triple_', ()=>{
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 })
-test('be_rsig_triple_|+id|+is_source_|+oninit', ()=>{
+test('be_rsig_triple_|+id|+is_source_', ()=>{
 	const ctx = ctx__new()
 	let subscriber_count = 0
 	const [
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_rsig_triple_<number, readwrite_rmemo_T<number>&{ custom:string }>(
+	] = be_rsig_triple_(
 		()=>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)
+		()=>subscriber_count++,
+		{ id: 'foobar', is_source_: map_ctx=>map_ctx === ctx },)
+	equal(subscriber_count, 0)
+	equal(foobar$_([ctx__new(), ctx])._, 1)
+	equal(foobar_([ctx__new(), ctx]), 1)
+	equal(foobar$_(ctx)._, 1)
+	equal(foobar_(ctx), 1)
+	equal(subscriber_count, 1)
+	equal((ctx.get('foobar') as readwrite_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(subscriber_count, 1)
+})
+test('be_rsig_triple_|+be', ()=>{
+	const ctx = ctx__new()
+	let subscriber_count = 0
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = be_rsig_triple_<number, custom_rsig_T>(
+		be_(()=>{
+			const foobar$ =
+				rsig_(1, ()=>subscriber_count++) as custom_rsig_T
 			foobar$.custom = 'custom-val'
-		})
+			return foobar$
+		}, { id: 'foobar', is_source_: map_ctx=>map_ctx === ctx }))
 	equal(subscriber_count, 0)
 	equal(foobar$_([ctx__new(), ctx])._, 1)
 	equal(foobar_([ctx__new(), ctx]), 1)
@@ -50,3 +75,4 @@ test('be_rsig_triple_|+id|+is_source_|+oninit', ()=>{
 	equal(subscriber_count, 1)
 })
 test.run()
+type custom_rsig_T = readwrite_rmemo_T<number>&{ custom:string }

package/all/ctx/index.js

@@ -3,7 +3,9 @@
  * @private
  */
 export function ctx__new() {
-	return new Map([[Symbol.for('ctx'), true]])
+	let ctx = new Map
+	ctx.is_ctx = true
+	return ctx
 }
 export { ctx__new as ctx_ }
 /**
@@ -12,11 +14,8 @@ export { ctx__new as ctx_ }
  * @private
  */
 export function is_ctx_(val) {
-	if (!Array.isArray(val)) return !!(val instanceof Map && val.get(Symbol.for('ctx')))
-	if (!val.length) return false
-	let flat__val = val.flat(Infinity)
-	for (let i = 0; i < flat__val.length; i++) {
-		if (!is_ctx_(flat__val[i])) return false
-	}
-	return true
+	if (!Array.isArray(val)) return val instanceof Map && !!val.is_ctx
+	let flat__map_ctx_a = val.flat(Infinity)
+	if (!flat__map_ctx_a[0]) return false
+	return flat__map_ctx_a.every(map_ctx=>map_ctx.is_ctx)
 }

package/all/ctx/index.test.ts

@@ -12,5 +12,6 @@ test('is_ctx_', ()=>{
 	equal(is_ctx_([ctx0, [ctx1], [[[]]]]), true)
 	equal(is_ctx_(not_ctx), false)
 	equal(is_ctx_([ctx0, [ctx1], [[ctx2]], [not_ctx]]), false)
+	equal(is_ctx_([[], [[]], []]), false)
 })
 test.run()

package/all/index.d.ts

@@ -307,8 +307,6 @@ export * from './rad_deg/index.js'
 export * from './random_idx/index.js'
 export * from './rank/index.js'
 export * from './rate_limit/index.js'
-export * from './rc_be/index.js'
-export * from './rc_be_/index.js'
 export * from './reduce/index.js'
 export * from './reject/index.js'
 export * from './remove/index.js'

package/all/index.js

@@ -307,8 +307,6 @@ export * from './rad_deg/index.js'
 export * from './random_idx/index.js'
 export * from './rank/index.js'
 export * from './rate_limit/index.js'
-export * from './rc_be/index.js'
-export * from './rc_be_/index.js'
 export * from './reduce/index.js'
 export * from './reject/index.js'
 export * from './remove/index.js'

package/all/rmemo/index.js

@@ -1,9 +1,9 @@
 /** @typedef {import('./index.d.ts').rmemo_T} */
 /** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
-/** @type {(()=>unknown)[]} */
-let queue = []
 /** @type {WeakRef<rmemo_T>} */
 let cur_ref
+/** @type {(()=>unknown)[]} */
+let queue = []
 /**
  * @param {(rmemo:rmemo_T<unknown>)=>unknown}_f
  * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
@@ -21,7 +21,6 @@ export function rmemo_(_f, ...subscriber_a) {
 	rmemo._rS = new Set
 	rmemo.go = ()=>(rmemo(), rmemo)
 	rmemo.onset = ()=>0
-	let c = 0
 	Object.defineProperty(rmemo, '_', {
 		get() {
 			if (!_a.length) {
@@ -44,7 +43,6 @@ export function rmemo_(_f, ...subscriber_a) {
 			if (!_a.length || val !== _a[0]) {
 				rmemo.refresh(val)
 			}
-			return val
 		}
 	})
 	rmemo.refresh = val=>{
@@ -60,6 +58,7 @@ export function rmemo_(_f, ...subscriber_a) {
 					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)
@@ -79,8 +78,7 @@ export function rmemo_(_f, ...subscriber_a) {
  * @private
  */
 export function rsig_(init_val, ...subscriber_a) {
-	let rsig =
-		rmemo_(signal$=>signal$._v, ...subscriber_a)
+	let rsig = rmemo_(_rsig=>_rsig._v, ...subscriber_a)
 	rsig.onset = val=>rsig._v = val
 	rsig._v = init_val
 	return rsig

package/object/index.d.ts

@@ -39,8 +39,6 @@ export * from '../all/pick/index.js'
 export * from '../all/pick_keys/index.js'
 export * from '../all/pick_val_a/index.js'
 export * from '../all/prototype/index.js'
-export * from '../all/rc_be/index.js'
-export * from '../all/rc_be_/index.js'
 export * from '../all/toString/index.js'
 export * from '../all/unpick/index.js'
 export * from '../all/unpick_keys/index.js'

package/object/index.js

@@ -38,8 +38,6 @@ export * from '../all/pick/index.js'
 export * from '../all/pick_keys/index.js'
 export * from '../all/pick_val_a/index.js'
 export * from '../all/prototype/index.js'
-export * from '../all/rc_be/index.js'
-export * from '../all/rc_be_/index.js'
 export * from '../all/toString/index.js'
 export * from '../all/unpick/index.js'
 export * from '../all/unpick_keys/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -124,33 +124,54 @@
   },
   "sideEffects": false,
   "size-limit": [
+    {
+      "name": "ctx_",
+      "import": {
+        "./be": "{ ctx_ }"
+      },
+      "limit": "34 B"
+    },
     {
       "name": "be_",
       "import": {
         "./be": "{ be_ }"
       },
-      "limit": "367 B"
+      "limit": "162 B"
+    },
+    {
+      "name": "be_ ctx_",
+      "import": {
+        "./be": "{ be_, ctx_ }"
+      },
+      "limit": "187 B"
     },
     {
       "name": "rmemo_",
       "import": {
         "./rmemo": "{ rmemo_ }"
       },
-      "limit": "355 B"
+      "limit": "344 B"
     },
     {
       "name": "rmemo_ signal_",
       "import": {
         "./rmemo": "{ rsig_, rmemo_ }"
       },
-      "limit": "381 B"
+      "limit": "372 B"
     },
     {
       "name": "rmemo_ signal_ be_ ctx_",
       "import": {
         "./rmemo": "{ rsig_, rmemo_, be_, ctx_ }"
       },
-      "limit": "731 B"
+      "limit": "532 B"
+    },
+    {
+      "name": "rmemo_ signal_ be_ ctx_ be_rmemo_pair_ be_rsig_triple_",
+      "import": {
+        "./rmemo": "{ rsig_, rmemo_, be_, ctx_, be_rmemo_pair_, be_rsig_triple_ }"
+      },
+      "limit": "613 B"
     }
   ],
   "scripts": {

package/all/be_/debug.js

@@ -1,25 +0,0 @@
-import { be_ } from './index.js'
-export function be__debug() {
-  be_.argv__debug = argv__ctx=>{
-	  if (!argv__ctx) {
-	  	throw new Error(`be: no Ctx`)
-	  }
-  }
-	be_.source__debug = ctx=>{
-		if (!ctx) {
-			throw new Error(
-				`be: ${String(id)}: no is_source_ returns true`)
-		}
-	}
-	be_.pending__debug = pending=>{
-		if (pending.get(be)) {
-			throw new Error(
-				`be_: ${
-					String(id)
-				}: circular:\n${pending.values().map(pending_value=>
-					typeof pending_value === 'string'
-						? pending_value
-						: 'Function').join('\n')}`)
-		}
-	}
-}

package/all/rc_be/index.d.ts

@@ -1,6 +0,0 @@
-import type { Ctx } from '../be_/index.js'
-import type { rc_be__val__new_T } from '../rc_be_/index.js'
-export declare function rc_be<
-	Out extends NonNullable<unknown>
->(ctx:Ctx, val_:rc_be__val__new_T<Out>):Out
-export { rc_be as rc_b, }

package/all/rc_be/index.js

@@ -1,15 +0,0 @@
-import { rc_be_ } from '../rc_be_/index.js'
-/** @typedef {import('../be_/index.d.ts').Ctx} */
-/** @typedef {import('../rc_be_/index.d.ts').rc_be__val__new_T} */
-/**
- * @param {Ctx}ctx
- * @param {rc_be__val__new_T<NonNullable<unknown>>}key_or_val
- * @returns {NonNullable<unknown>}
- */
-export function rc_be(
-	ctx,
-	val__new
-) {
-	return rc_be_(val__new)(ctx)
-}
-export { rc_be as rc_b, }

package/all/rc_be_/index.d.ts

@@ -1,39 +0,0 @@
-import type { Be, be__val__new_T, be_params_T, Ctx } from '../be_/index.js'
-export declare const be_m_set_key:unique symbol
-/**
- * Returns _be with referencing counting.
- * When all unsubscribes have been called, the ctx[key] is deleted.
- */
-export declare function rc_be_<
-	Out extends NonNullable<unknown>
->(val__new:rc_be__val__new_T<Out>):rc_be__return_T<Out>
-export declare type rc_be__return_T<
-	Out extends NonNullable<unknown>
-> = (ctx:Ctx, params?:rc_be_params_T)=>RcBe_return_T<Out>
-export {
-	rc_be_ as _rc_be,
-	rc_be_ as _rc_b,
-}
-export declare type be_m_set_T<
-	Out extends NonNullable<unknown>
-> = Map<Be<Out>, Set<any>>
-export declare type val_this_on_destroy_T = (...destroy_a:rc_be_destroy_T[])=>void
-export interface val_this_T {
-	on_destroy:val_this_on_destroy_T
-	onDestroy:val_this_on_destroy_T
-}
-export interface rc_be_params_T extends be_params_T {
-	owner?:object
-}
-export declare type rc_be__val__new_T<
-	Out extends NonNullable<unknown>
-> = be__val__new_T<Out>&((this:val_this_T, ctx:Ctx, key:Be<Out>, opts?:rc_be_params_T)=>Out)
-export declare type rc_be_destroy_T = ()=>void
-export interface RcBe_return_T<Out extends unknown = unknown> {
-	value:Out
-	destroy:rc_be_destroy_T
-}
-export declare type RcBe<
-	Out extends NonNullable<unknown>
-> = (ctx:Ctx, opts?:be_params_T)=>RcBe_return_T<Out>
-export declare type RcB<Out extends NonNullable<unknown>> = RcBe<Out>

package/all/rc_be_/index.js

@@ -1,53 +0,0 @@
-import { be_ } from '../be_/index.js'
-/** @typedef {import('../rc_be_/index.d.ts').rc_be__val__new_T} */
-export const be_m_set_key = Symbol('be_m_set')
-/**
- * @param {rc_be__val__new_T}val__new
- * @returns {import('./index.d.ts').rc_be__return_T}
- * @private
- */
-export function rc_be_(val__new) {
-	return (ctx1, opts1)=>{
-		const ctx_any = ctx1
-		const destroy_cb_a = []
-		const val_this = {
-			on_destroy,
-			onDestroy: on_destroy
-		}
-		/** @type {rc_be__val__new_T} */
-		const val__new = val__new ? val__new : key_or_val_
-		const be1 = be_(val__new)
-		let be_m_set = ctx_any[be_m_set_key]
-		if (!be_m_set) {
-			be_m_set = new Map()
-			ctx_any[be_m_set_key] = be_m_set
-		}
-		let rc_set = be_m_set.get(be1)
-		if (!rc_set) {
-			rc_set = new Set()
-			be_m_set.set(be1, rc_set)
-		}
-		const owner = (opts1 === null || opts1 === void 0 ? void 0 : opts1.owner) || {}
-		rc_set.add(owner)
-		let destroy = ()=>{
-			rc_set.delete(owner)
-			if (!rc_set.size) {
-				for (const destroy_cb of destroy_cb_a) {
-					destroy_cb()
-				}
-				ctx1.delete(be1)
-			}
-		}
-		return {
-			value: be1(ctx1, opts1),
-			destroy
-		}
-		function on_destroy(...in_destroy_cb_a) {
-			destroy_cb_a.push(...in_destroy_cb_a)
-		}
-	}
-}
-export {
-	rc_be_ as _rc_be,
-	rc_be_ as _rc_b,
-}