ctx-core 4.19.0 → 5.0.0

package/all/a_in_idx_a_map/index.d.ts

@@ -1,9 +1,7 @@
 /**
  * Returns Array of values from `a` with index in `idx_a`.
  */
-export declare function a_in_idx_a_map<
-	Val extends unknown = unknown
->(
+export declare function a_in_idx_a_map<Val>(
 	idx_a:readonly number[], a:readonly Val[]
 ):Val[]
 export {

package/all/a_item/index.d.ts

@@ -1,12 +1,6 @@
-export declare type a_item_T<
-	I extends unknown = unknown
-> =
+export declare type a_item_T<I> =
 	I extends readonly (infer O)[]
 		? O
 		: I
-export declare type a1_item_type<
-	I extends unknown = unknown
-> = a_item_T<I>
-export declare type a1_item_T<
-	I extends unknown = unknown
-> = a_item_T<I>
+export declare type a1_item_type<I> = a_item_T<I>
+export declare type a1_item_T<I> = a_item_T<I>

package/all/a_length/index.d.ts

@@ -1,13 +1,10 @@
 /**
  * Returns length of `in_a`
  */
-export declare function a_length_<
-	Val extends unknown = unknown
->(a:readonly Val[]):number
-export declare function maybe_a__length_<
-	Val extends unknown = unknown, Or = null
->(
-	maybe_a:readonly Val[]|undefined, or?:Or
+export declare function a_length_<Val>(a:readonly Val[]):number
+export declare function maybe_a__length_<Val, Or = null>(
+	maybe_a:readonly Val[]|undefined,
+	or?:Or
 ):number|Or
 export {
 	a_length_ as a_length_fn,

package/all/a_nowrap/index.d.ts

@@ -1,6 +1,4 @@
-export declare type a_nowrap_T<
-	I extends unknown = unknown
-> =
+export declare type a_nowrap_T<I> =
 	I
 	|readonly I[]
 	|readonly I[][]

package/all/a_present/index.d.ts

@@ -2,13 +2,10 @@ import { a_length_ } from '../a_length/index.js'
 /**
  * Returns true if `a` has a length
  */
-export declare function a_present_<
-	Val extends unknown = unknown
->(a:readonly Val[]):boolean
-export declare function maybe_a_present_fn<
-	Val extends unknown = unknown, Or = null
->(
-	maybe_a:readonly Val[]|undefined, or?:Or
+export declare function a_present_<Val>(a:readonly Val[]):boolean
+export declare function maybe_a_present_fn<Val, Or = null>(
+	maybe_a:readonly Val[]|undefined,
+	or?:Or
 ):boolean|Or
 export {
 	a_present_ as a1_present_fn,

package/all/a_some/index.d.ts

@@ -1,9 +1,7 @@
 /**
  * Returns true if some `predicate(value)` is truthy
  */
-export declare function a_some<
-	Val extends unknown = unknown, POut extends unknown = unknown
->(
+export declare function a_some<Val, POut>(
 	a:readonly Val[],
 	predicate:(val:Val, index:number, a:readonly Val[])=>POut
 ):boolean

package/all/and/index.d.ts

@@ -3,17 +3,11 @@ import type { falsy } from '../falsy/index.js'
 /**
  * Returns the first falsy or last item.
  */
-export declare function and<
-	I extends unknown = unknown,
-	O extends unknown = I
->(a_nowrap:a_nowrap_T<I>):O|falsy
+export declare function and<I, O = I>(a_nowrap:a_nowrap_T<I>):O|falsy
 /**
  * Returns the first falsy or last item function call or value in `in_value_a` .
  */
-export declare function and_<
-	I extends unknown = unknown,
-	O extends unknown = I
->(a_nowrap:I):O|falsy
+export declare function and_<I, O = I>(a_nowrap:I):O|falsy
 export { and_ as and__fn }
 /**
  * Returns function that returns the first falsy or last item function call or value in `in_value_a` .
@@ -21,7 +15,7 @@ export { and_ as and__fn }
 export declare function and_2<
 	A_outer extends unknown[] = unknown[],
 	A_inner extends unknown[] = unknown[],
-	O extends unknown = unknown
+	O = unknown
 >(in_value_a:A_inner):(fn_value_a:A_outer)=>O|falsy
 export {
 	and_2 as _and_fn,

package/all/and_call/index.d.ts

@@ -1,14 +1,10 @@
 /**
  * Returns a function than returns the called fn_a(value) chained with ands
  */
-export declare function and_call_<
-	I extends unknown = unknown,
-	O extends unknown = unknown
->(fn_a:((in_value:I)=>O)[]):and_fn_call_T<I, O>;
-export declare type and_fn_call_T<
-	I extends unknown = unknown,
-	O extends unknown = unknown
-> = (in_value:I)=>O|null
+export declare function and_call_<I, O>(
+	fn_a:((in_value:I)=>O)[]
+):and_fn_call_T<I, O>
+export declare type and_fn_call_T<I, O> = (in_value:I)=>O|null
 export {
 	and_call_ as and_fn_call_fn,
 	and_call_ as _and_fn_call,

package/all/andand/index.d.ts

@@ -1,14 +1,7 @@
 /**
  * Applies `&&` to a chain of properties from `obj`.
  */
-export declare function andand<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
->(obj:Val, ...name_a:andand_key_T<Val>[]):Out|null
-export declare type andand_key_T<
-	Val extends unknown = unknown
-> = keyof Val|andand_key__T<Val>
-export declare type andand_key__T<
-	Val extends unknown = unknown
-> = (val:Val)=>keyof Val
-export declare type andand_key_fn_T = andand_key__T
+export declare function andand<Val, Out>(obj:Val, ...name_a:andand_key_T<Val>[]):Out|null
+export declare type andand_key_T<Val> = keyof Val|andand_key__T<Val>
+export declare type andand_key__T<Val> = (val:Val)=>keyof Val
+export declare type andand_key_fn_T<Val> = andand_key__T<Val>

package/all/andand_or/index.d.ts

@@ -2,12 +2,10 @@ import type { andand_key_T } from '../andand/index.js'
 /**
  * Returns `andand(obj, name_a) || or_fn(obj, val)`
  */
-export declare function andand_or<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
->(obj:Val, name_a:andand_key_T<Val>[], or_:andand_or_T<Val, Out>):Out
-export declare type andand_or_T<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
-> = (val:Out|null, obj:Val)=>Out
+export declare function andand_or<Val, Out>(
+	obj:Val,
+	name_a:andand_key_T<Val>[],
+	or_:andand_or_T<Val, Out>
+):Out
+export declare type andand_or_T<Val, Out> = (val:Out|null, obj:Val)=>Out
 export { andand_or as andand__or }

package/all/andandfn/index.d.ts

@@ -2,22 +2,13 @@ import type { andand_key_T } from '../andand/index.js'
 /**
  * Applies `&&` to a chain of property name or function with return value from `obj`.
  */
-export declare function andandfn<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
->(obj:Val, ...name_a:andand_key_T<Val>[]):Out
-export declare type andandfn_T<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
-> = (obj:Val)=>Out
+export declare function andandfn<Val, Out>(obj:Val, ...name_a:andand_key_T<Val>[]):Out
+export declare type andandfn_T<Val, Out> = (obj:Val)=>Out
 export { andandfn as andand__fn, }
 /**
  * Returns a function that calls `andand_(obj, ...name_a)`
  */
-export declare function andandfn_<
-	In extends unknown = unknown,
-	Out extends unknown = unknown
->(
+export declare function andandfn_<In, Out>(
 	...name_a:andand_key_T<In>[]
 ):andandfn_T<In, Out>
 export {

package/all/apply/index.d.ts

@@ -5,9 +5,9 @@ import type { call_fn_T } from '../call/index.js'
  */
 export declare function apply_<
 	A1 extends unknown[] = unknown[],
-	O1 extends unknown = unknown,
+	O1 = unknown,
 	A2 extends unknown[] = unknown[],
-	O2 extends unknown = unknown
+	O2 = unknown
 >(
 	fn:call_fn_T<A2, O2>, in_arg_a?:unknown[]
 ):bind_call_T<A1, O1>

package/all/arg_i0_a/index.d.ts

@@ -4,7 +4,7 @@ import type { slice_arg_spread_a___ret_T, slice_arg_spread_a__arg__T } from '../
  */
 export declare function arg_i0_a<
 	In extends unknown[] = unknown[],
-	Out extends unknown = unknown
+	Out = unknown
 >(
 	fn:slice_arg_spread_a__arg__T<In, Out>
 ):slice_arg_spread_a___ret_T<In, Out>

package/all/array_types/index.d.ts

@@ -88,47 +88,40 @@ export interface sort_val_a__transition_a_frame_T<I> {
 export declare type sort_val_a$transition_a_frame_T<I> = sort_val_a__transition_a_frame_T<I>
 export declare type compact_a_ctx_I<I> = sort_val_a__transition_a_frame_T<I>
 export declare type compact_a1_ctx_I<I> = sort_val_a__transition_a_frame_T<I>
-export declare type compare_1_T<
-	Val extends unknown = unknown
-> = (val:Val, idx?:number)=>number
-export declare type compare_T<
-	I extends unknown = unknown
-> = (a:I, b:I)=>number
-export declare type is_match__T<
-	Val extends unknown = unknown
-> = (in_value:Val, idx:number)=>boolean
-export declare type is_match_fn_T<Val extends unknown = unknown> = is_match__T<Val>
-export declare type _is_match_T<Val extends unknown = unknown> = is_match__T<Val>
-export declare type _is_match_type<Val extends unknown = unknown> = is_match__T<Val>
+export declare type compare_1_T<Val> = (val:Val, idx?:number)=>number
+export declare type compare_T<I> = (a:I, b:I)=>number
+export declare type is_match__T<Val> = (in_value:Val, idx:number)=>boolean
+export declare type is_match_fn_T<Val> = is_match__T<Val>
+export declare type _is_match_T<Val> = is_match__T<Val>
+export declare type _is_match_type<Val> = is_match__T<Val>
 export declare type item_key_idx_val_fn_T<
-	Val extends unknown = unknown,
+	Val,
 	Obj extends Record<string, Val> = Record<string, Val>
 > = (val:Val, item:Obj, key:string|number, idx:number)=>string
 export declare type _item_key_idx_val_T<
-	Val extends unknown = unknown,
+	Val,
 	Obj extends Record<string, Val> = Record<string, Val>
 > = item_key_idx_val_fn_T<Val, Obj>
 export declare type _item_key_idx_val_type<
-	Val extends unknown = unknown,
+	Val,
 	Obj extends Record<string, Val> = Record<string, Val>
 > = item_key_idx_val_fn_T<Val, Obj>
-export declare type sort_idx_ctx__T<I extends unknown = unknown> = (
+export declare type sort_idx_ctx__T<I> = (
 	a:readonly I[])=>sort_idx_o_T<I>
-export declare type sort_idx_ctx_2_T<I extends unknown = unknown> = sort_idx_ctx__T<I>
-export declare type sort_idx_ctx_a1_fn_type<I extends unknown = unknown> = sort_idx_ctx__T<I>
-export declare type fn__a1__ctx__idx__sort<I extends unknown = unknown> = sort_idx_ctx__T<I>
-export interface sort_idx_o_T<I extends unknown = unknown> {
+export declare type sort_idx_ctx_2_T<I> = sort_idx_ctx__T<I>
+export declare type sort_idx_ctx_a1_fn_type<I> = sort_idx_ctx__T<I>
+export declare type fn__a1__ctx__idx__sort<I> = sort_idx_ctx__T<I>
+export interface sort_idx_o_T<I> {
 	sort_idx_a:readonly number[]
 	sort_val_a:I[]
 }
-export declare type sort_idx_ctx_T<I extends unknown = unknown> = sort_idx_o_T<I>
-export declare type ctx__idx__sort<I extends unknown = unknown> = sort_idx_o_T<I>
-export declare type sort_val_a__transition_a_frame_fn_T<
-	I extends unknown = unknown
-> = (in_val_a:readonly I[]|undefined)=>sort_val_a__transition_a_frame_T<I>
-export declare type sort_val_a$transition_a_frame_fn_T<I extends unknown = unknown> =
+export declare type sort_idx_ctx_T<I> = sort_idx_o_T<I>
+export declare type ctx__idx__sort<I> = sort_idx_o_T<I>
+export declare type sort_val_a__transition_a_frame_fn_T<I> =
+	(in_val_a:readonly I[]|undefined)=>sort_val_a__transition_a_frame_T<I>
+export declare type sort_val_a$transition_a_frame_fn_T<I> =
 	sort_val_a__transition_a_frame_T<I>
-export declare type thold_a_compact_ctx__T<I extends unknown = unknown> =
+export declare type thold_a_compact_ctx__T<I> =
 	sort_val_a__transition_a_frame_fn_T<I>
-export declare type thold_a1_compact_ctx_fn_type<I extends unknown = unknown> =
+export declare type thold_a1_compact_ctx_fn_type<I> =
 	sort_val_a__transition_a_frame_fn_T<I>

package/all/assign_fn_key_a/index.d.ts

@@ -2,9 +2,7 @@ import type { assign_fn_T } from '../call_assign/index.js'
 /**
  * Assigns to obj array of keys the return value of function in key_a_fn_aa.
  */
-export declare function assign_fn_key_a<
-	I extends unknown = unknown
->(
+export declare function assign_fn_key_a<I>(
 	obj:Record<string, I>,
 	...key_a_fn_aa:fn_key_a_tuple_T<I>[]
 ):Record<string, I>

package/all/be/index.d.ts

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

package/all/be_/index.d.ts

@@ -1,8 +1,10 @@
-export declare const pending_symbol:unique symbol
 export declare function globalThis__be_<
 	val_T,
-	ctx_T extends Ctx = Ctx
->(val__new:be__val__new_T<val_T, ctx_T>, config:be_config_T&{ id: string }):Be<val_T, ctx_T>
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>
+>(val__new:be__val__new_T<val_T, ns_T, ctx_T>, config:be_config_T<ns_T>&{
+	id:string
+}):Be<val_T, ns_T, ctx_T>
 /**
  * Auto-memoization function for the Ctx.
  *
@@ -11,69 +13,88 @@ export declare function globalThis__be_<
  */
 export declare function be_<
 	val_T,
-	ctx_T extends Ctx = Ctx
->(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 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_T, is_source_:is_source__T):MapCtx
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+>(
+	val__new:be__val__new_T<val_T, ns_T, ctx_T>,
+	config?:be_config_T<ns_T>
+):Be<val_T, ns_T, ctx_T>
 export declare function ctx__set<
 	val_T,
-	ctx_T extends Ctx = Ctx
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 >(
 	ctx:ctx_T,
 	be_OR_id:Be<val_T>|string|symbol,
 	val:val_T,
-	is_source_?:is_source__T
+	ns?:ns_T
 ):void
 export declare function ctx__delete<
-	val_T,
-	ctx_T extends Ctx = Ctx
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
 >(
 	ctx:ctx_T,
-	be_OR_id:Be<val_T>|string|symbol,
-	is_source_?:is_source__T
+	be_OR_id:Be<unknown, ns_T, ctx_T>|string|symbol,
+	ns?:string
 ):void
 export declare function be__has_<
-	ctx_T extends Ctx = Ctx
->(be_OR_id:Be<unknown>|string, ctx:ctx_T):boolean
-export declare function be__ctx_<
-	ctx_T extends Ctx = Ctx
->(be_OR_id:Be<unknown>|string, ctx:ctx_T):MapCtx
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+>(be_OR_id:Be<unknown, ns_T, ctx_T>|string, ctx:ctx_T, ns?:ns_T):boolean
+export declare function be_map__find<
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+>(be_OR_id:Be<unknown, ns_T, ctx_T>|string, ctx:ctx_T, ns?:ns_T):BeMap<ns_T>
 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 type MapCtx = Map<Be<unknown>|string|symbol, unknown>&{ is_ctx: true }
-export type NestedMapCtx = Array<NestedMapCtx|MapCtx>
-export type Ctx = MapCtx|NestedMapCtx
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+>(be_OR_id:Be<val_T, ns_T, ctx_T>|string, ctx:ctx_T, ns?:ns_T):val_T|unknown|null
 export declare type Be<
 	val_T,
-	ctx_T extends Ctx = Ctx
-> = ((ctx:ctx_T)=>val_T)&{
-	is_be: true
-	id:string|Be<val_T, ctx_T>
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+> = ((ctx:ctx_T)=>val_T)&be_o_T<val_T, ns_T, ctx_T>
+export type be_o_T<
+	val_T,
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>,
+> = {
+	id:string|Be<val_T, ns_T, ctx_T>
+	ns:ns_T
+	is_be:true
 }
-export type be_config_T = {
+export type be_config_T<ns_T extends string = string> = {
 	id?:string
-	is_source_?:is_source__T
+	ns?:ns_T
 }
-export declare type be__return_T<
-	val_T,
-	ctx_T extends Ctx = Ctx
-> = Be<val_T, ctx_T>
-export declare type be_T<
-	val_T,
-	ctx_T extends Ctx = Ctx
-> = Be<val_T, ctx_T>
+export type BeMap<
+	ns_T extends string = ''
+> = Map<Be<unknown, ns_T, Ctx_wide_T<ns_T>>|string|symbol, unknown>
+export type BeMapO<ns_union_T extends string> =
+	{ [K in ns_union_T]:BeMap<K> }
 export declare type be__val__new_T<
 	val_T,
-	ctx_T extends Ctx = Ctx
-> = (ctx:ctx_T, be:Be<val_T, ctx_T>)=>val_T
-export type is_source__T = (map_ctx:MapCtx, ctx:Ctx)=>boolean
+	ns_T extends string = '',
+	ctx_T extends Ctx = Ctx_wide_T<ns_T>
+> = (ctx:ctx_T, be:Be<val_T, ns_T, ctx_T>)=>val_T
+export type Ctx<ns_T extends string = string> = Readonly<{
+	s:Ctx_s_T<ns_T>
+	is_ctx:true
+	/**
+	 * Used for type inference narrowing. There is no js implementation.
+	 */
+	ns_T?:ns_T
+}>
+export type Ctx_wide_T<ns_union_T extends string> =
+	Ctx&Ctx_s_wide_T<ns_union_T>
+export type Ctx_s_T<ns_union_T extends string = string> = {
+	[K in ns_union_T]:BeMap<K>
+}
+export type Ctx_s_wide_T<ns_union_T extends string> = {
+	s:BeMapO<ns_union_T>
+}
+export type ctx__be_T<ctx_T extends Ctx, be_val_T, ns_T extends string> =
+	Be<be_val_T, ns_T, ctx_T>
+export type ctx__get_T<ctx_T extends Ctx, val_T> = (ctx:ctx_T)=>val_T
+export type ctx__set_T<ctx_T extends Ctx, val_T> = (ctx:ctx_T, val:val_T)=>void

package/all/be_/index.js

@@ -1,10 +1,5 @@
-/** @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} */
-/** @typedef {import('./index.d.ts').is_source__T} */
+/// <reference types="./index.d.ts" />
+let _undefined
 /**
  * Auto-memoization function for the Ctx.
  *
@@ -16,27 +11,22 @@
  * @private
  */
 export function be_(val__new, config) {
-	let be = argv__ctx=>{
-		let flat__argv__ctx = argv__ctx.flat && argv__ctx.flat(Infinity)
-		let be__ctx =
-		  flat__argv__ctx
-	      ? flat__argv__ctx.find(ctx=>ctx.has(be.id))
-	      : argv__ctx.has(be.id) && 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, '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.id, 'cir')
-			be__ctx.set(be.id, val__new(argv__ctx, be))
-		}
-		return be__ctx.get(be.id)
+	let be = ctx=>{
+		let be_map = ctx.s[be.ns]
+		/* @if DEBUG **
+			// ~ 30 B
+			if (!be_map) throw Error('ctx_no_ns: \'' + be.ns + '\'')
+		/* @endif */
+		if (be_map.has(be.id)) return be_map.get(be.id)
+		// circular dependency state
+		// if val__new calls this be before returning, 'cir' will be the value of this be
+		// 'cir' is used instead of 'circular' to reduce the payload by a few bytes
+		be_map.set(be.id, 'cir')
+		be_map.set(be.id, val__new(ctx, be))
+		return be_map.get(be.id)
 	}
 	be.id = config?.id ?? be
-	be.is_source_ = config?.is_source_
+	be.ns = config?.ns ?? ''
 	be.is_be = true
 	return be
 }
@@ -57,7 +47,7 @@ export { be_ as globalThis__be_ }
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
  * @param {unknown}val
- * @param {is_source__T}[is_source_]
+ * @param {string}[ns]
  * @returns {unknown}
  * @private
  */
@@ -65,80 +55,53 @@ export function ctx__set(
 	ctx,
 	be_OR_id,
 	val,
-	is_source_ = be_OR_id.is_source_
+	ns = be_OR_id.ns ?? ''
 ) {
-	let source__map_ctx = source__map_ctx_(ctx, is_source_)
-	if (source__map_ctx) {
-		source__map_ctx.set(be_OR_id.id ?? be_OR_id, val)
-	}
+	ctx.s[ns].set(be_OR_id.id ?? be_OR_id, val)
 }
 /**
  * @param {Ctx}ctx
  * @param {Be|string|symbol}be_OR_id
+ * @param {string}[ns]
  */
 export function ctx__delete(
 	ctx,
 	be_OR_id,
+	ns = be_OR_id.ns ?? ''
 ) {
-	if (Array.isArray(ctx)) {
-		for (let _ctx of ctx) {
-			ctx__delete(_ctx, be_OR_id)
-		}
+	if (ns != null) {
+		ctx.s[ns].delete(be_OR_id.id ?? be_OR_id)
 	} else {
-		ctx.delete(be_OR_id.id ?? be_OR_id)
+		for (let _source in ctx.s) {
+			ctx.s[_source].delete(be_OR_id.id ?? be_OR_id)
+		}
 	}
 }
 /**
- * @param {Be|string}be_or_id
- * @param {Ctx}argv__ctx
+ * @param {[Be|string, Ctx]|[Be|string, Ctx, string]}arg_a
  * @returns {boolean}
  * @private
  */
-export function be__has_(be_or_id, argv__ctx) {
-	return Boolean(be__ctx_(be_or_id, argv__ctx))
+export function be__has_(...arg_a) {
+	return Boolean(be_map__find(...arg_a))
 }
 /**
- * @param {Be|string}be_or_id
- * @param {Ctx}argv__ctx
- * @returns {MapCtx}
+ * @param {Be}be_or_id
+ * @param {Ctx}ctx
+ * @param {string}[ns]
+ * @returns {Ctx}
  * @private
  */
-export function be__ctx_(be_or_id, argv__ctx) {
-	if (Array.isArray(argv__ctx)) {
-		for (let ctx of argv__ctx) {
-			let be__ctx = be__ctx_(be_or_id.id ?? be_or_id, ctx)
-			if (be__ctx) return be__ctx
-		}
-	} else {
-		if (argv__ctx.has(be_or_id.id ?? be_or_id)) return argv__ctx
-	}
+export function be_map__find(be_or_id, ctx, ns = be_or_id.ns ?? '') {
+	return ctx.s[ns].has(be_or_id.id ?? be_or_id) ? ctx.s[ns] : _undefined
 }
-export { be__ctx_ as be__has__ctx_ }
 /**
  * @param {Be|string}be_or_id
- * @param {Ctx}argv__ctx
- * @returns {unknown}
- * @private
- */
-export function be__val_(be_or_id, argv__ctx) {
-	let be__ctx = be__ctx_(be_or_id, argv__ctx)
-	if (be__ctx) return be__ctx.get(be_or_id.id ?? be_or_id)
-}
-/**
- * @param {Ctx}argv__ctx
- * @param {is_source__T}is_source_
+ * @param {Ctx}ctx
+ * @param {string}[ns]
  * @returns {unknown}
  * @private
  */
-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_(argv__ctx, argv__ctx)) {
-			return argv__ctx
-		}
-	}
+export function be__val_(be_or_id, ctx, ns) {
+	return be_map__find(be_or_id, ctx, ns)?.get?.(be_or_id.id ?? be_or_id)
 }