ctx-core 5.23.0 → 5.25.0

package/all/be_/index.d.ts

@@ -17,7 +17,35 @@ export declare function be_<
 	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
 >(
 	val__new:be__val__new_T<val_T, ns_T, ctx_T>,
-	config?:be_config_T<ns_T>
+	...config:be_config_arg_a_T<ns_T>
+):Be<val_T, ns_T, ctx_T>
+export type be_config_arg_a_T<ns_T extends string = ''> =
+	ns_T extends ''
+		? []|[config:be_config_T<ns_T>]
+		: [config:be_config_T<ns_T>]
+export declare function ns_be_<
+	val_T,
+	ns_T extends string,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:be__val__new_T<val_T, ns_T, ctx_T>
+):Be<val_T, ns_T, ctx_T>
+export declare function id_be_<
+	val_T,
+	ctx_T extends Ctx_wide_T<''> = Ctx_wide_T<''>,
+>(
+	id:string,
+	val__new:be__val__new_T<val_T, '', ctx_T>
+):Be<val_T, '', ctx_T>
+export declare function ns_id_be_<
+	val_T,
+	ns_T extends string,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:be__val__new_T<val_T, ns_T, ctx_T>
 ):Be<val_T, ns_T, ctx_T>
 export declare function ctx__set<
 	val_T,
@@ -88,10 +116,10 @@ export type be_o_T<
 	ns:ns_T
 	is_be:true
 }
-export type be_config_T<ns_T extends string = string> = {
-	id?:string
-	ns?:ns_T
-}
+export type be_config_T<ns_T extends string = string> =
+	ns_T extends ''
+		? { id?:string, ns?:ns_T }
+		: { id?:string, ns:ns_T }
 export type BeMap<
 	ns_T extends string = ''
 > =

package/all/be_/index.js

@@ -40,6 +40,34 @@ export function be_(val__new, config) {
 	be.is_be = true
 	return be
 }
+/**
+ * @param {string}ns
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function ns_be_(ns, val__new) {
+	return be_(val__new, { ns })
+}
+/**
+ * @param {string}id
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function id_be_(id, val__new) {
+	return be_(val__new, { id })
+}
+/**
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T}val__new
+ * @returns {Be}
+ * @private
+ */
+export function ns_id_be_(ns, id, val__new) {
+	return be_(val__new, { ns, id })
+}
 /**
  * Auto-memoization function for the Ctx.
  * Memoized on globalThis to allow packages being loaded multiple times, which can happen during bundling.

package/all/be_/index.test.ts

@@ -19,7 +19,7 @@ import {
 	type Ctx_s_T,
 	type Ctx_s_wide_T,
 	type Ctx_wide_T,
-	globalThis__be_,
+	globalThis__be_, id_be_, ns_be_, ns_id_be_,
 	ondelete_be_
 } from '../be_/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
@@ -88,7 +88,9 @@ test('be_|ns_ctx__new', ()=>{
 	equal(ctx1.s[''].has(root_.id), false)
 	equal(ctx2.s[''].has(root_.id), false)
 	equal(ctx3.s[''].has(root_.id), true)
-	const child_ = be_(ctx=>root_(ctx) + 1, { id: 'child_' })
+	const child_ = be_(
+		ctx=>root_(ctx) + 1,
+		{ id: 'child_' })
 	equal(child_(ctx), 2)
 	equal(ctx0.s[''].has(child_.id), true)
 	equal(ctx1.s[''].has(child_.id), false)
@@ -101,13 +103,14 @@ test('be_|ns', ()=>{
 	const ctx1 = ns_ctx__new('ctx1')
 	const ctx = ns_ctx__new(ctx0, ctx1)
 	const be__ctx_a:Ctx_wide_T<'ctx1'>[] = []
-	const root_ = be_(ctx=>{
-		be__ctx_a.push(ctx)
-		return 1
-	}, {
-		ns: 'ctx1',
-		id: 'root_'
-	})
+	const root_ = be_<number, 'ctx1'>(
+		ctx=>{
+			be__ctx_a.push(ctx)
+			return 1
+		}, {
+			id: 'root_',
+			ns: 'ctx1',
+		})
 	equal(root_(ctx), 1)
 	equal(be__ctx_a, [ctx])
 	// @ts-expect-error TS2322
@@ -148,7 +151,7 @@ test('be_|ns|types', ()=>{
 		? typeof ctx
 		: never>>
 	type test_ctx_Ctx = Expect<Equal<typeof ctx, Ctx<''|'ctx1'>>>
-	const root_ = be_(
+	const root_ = be_<number, 'ctx1'>(
 		ctx=>{
 			type test_be_ctx_argument = Expect<Equal<typeof ctx, Ctx_wide_T<'ctx1'>>>
 			return 1
@@ -207,6 +210,29 @@ test('be_|circular dependency|DEBUG=1', async ()=>{
 		await unlink(tempfile)
 	}
 })
+test('ns_be_', ()=>{
+	const valid_ctx = ns_ctx__new('test_ns')
+	const val_ = ns_be_('test_ns', ()=>true)
+	equal(val_(valid_ctx), true)
+	// @ts-expect-error TS2322
+	throws(()=>val_(ctx__new()))
+})
+test('id_be_', ()=>{
+	const valid_ctx = ctx__new()
+	const val_ = id_be_('test_id', ()=>true)
+	equal(val_(valid_ctx), true)
+	equal(val_.id, 'test_id')
+	// @ts-expect-error TS2322
+	throws(()=>val_(ns_ctx__new('test_ns')))
+})
+test('ns_id_be_', ()=>{
+	const valid_ctx = ns_ctx__new('test_ns')
+	const val_ = ns_id_be_('test_ns', 'test_id', ()=>true)
+	equal(val_(valid_ctx), true)
+	equal(val_.id, 'test_id')
+	// @ts-expect-error TS2322
+	throws(()=>val_(ctx__new()))
+})
 test('ctx__set', ()=>{
 	const ctx0 = ns_ctx__new('ctx0')
 	const ctx1 = ctx__new()
@@ -288,8 +314,7 @@ test('ctx__delete|be', ()=>{
 	// @ts-expect-error TS7053
 	equal(ctx1.s[''], undefined)
 	const ns__num_ =
-		be_(()=>1,
-			{ ns: 'ctx1' })
+		ns_be_('ctx1', ()=>1)
 	ns__num_(ns_ctx)
 	// @ts-expect-error TS2345
 	equal(ctx0.s[''].has(ns__num_.id), false)

package/all/be_lock_memosig_triple/index.d.ts

@@ -1,4 +1,4 @@
-import type { Be, be_config_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T, } from '../be_/index.js'
+import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T, } from '../be_/index.js'
 import type { lock_memosig_T } from '../rmemo/index.js'
 export declare function be_lock_memosig_triple_<
 	val_T,
@@ -13,7 +13,34 @@ export declare function be_lock_memosig_triple_<
 	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
 >(
 	rmemo__new:(ctx:ctx_T, memosig:lock_memosig_T<val_T, E>)=>val_T,
-	config?:be_config_T<ns_T>
+	...config:be_config_arg_a_T<ns_T>
+):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function ns_be_lock_memosig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function id_be_lock_memosig_triple_<
+	val_T,
+	E = unknown,
+	ctx_T extends Ctx_wide_T<''> = Ctx_wide_T<''>,
+>(
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_lock_memosig_triple_T<val_T, '', E, ctx_T>
+export declare function ns_id_be_lock_memosig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
 ):be_lock_memosig_triple_T<val_T, ns_T, E, ctx_T>
 export type be_lock_memosig_triple_T<
 	val_T,

package/all/be_lock_memosig_triple/index.js

@@ -37,3 +37,41 @@ export function be_lock_memosig_triple_(
 	}
 	return be_lock_memosig_triple
 }
+/**
+ * @param {string}ns
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_lock_memosig_triple_T}
+ * @private
+ */
+export function ns_be_lock_memosig_triple_(
+	ns,
+	val__new
+) {
+	return be_lock_memosig_triple_(val__new, { ns })
+}
+/**
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_lock_memosig_triple_T}
+ * @private
+ */
+export function id_be_lock_memosig_triple_(
+	id,
+	val__new
+) {
+	return be_lock_memosig_triple_(val__new, { id })
+}
+/**
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_lock_memosig_triple_T}
+ * @private
+ */
+export function ns_id_be_lock_memosig_triple_(
+	ns,
+	id,
+	val__new
+) {
+	return be_lock_memosig_triple_(val__new, { ns, id })
+}

package/all/be_lock_memosig_triple/index.test.ts

@@ -5,7 +5,12 @@ import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { memo_, memosig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
-import { be_lock_memosig_triple_ } from './index.js'
+import {
+	be_lock_memosig_triple_,
+	id_be_lock_memosig_triple_,
+	ns_be_lock_memosig_triple_,
+	ns_id_be_lock_memosig_triple_
+} from './index.js'
 test('be_lock_memosig_triple_', ()=>{
 	const [
 		,
@@ -149,4 +154,165 @@ test('be_lock_memosig_triple_|+be', ()=>{
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 3)
 })
+test('ns_be_lock_memosig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_be_lock_memosig_triple_(
+		'test_ns',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		},
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+})
+test('id_be_lock_memosig_triple_', ()=>{
+	const ctx = ctx__new()
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1)
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = id_be_lock_memosig_triple_(
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		},
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ctx, 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(add_count, 2)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_dep_(ctx), 7)
+})
+test('ns_id_be_lock_memosig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_id_be_lock_memosig_triple_(
+		'test_ns',
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		},
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(add_count, 2)
+	equal((ctx.s['test_ns'].get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_dep_(ctx), 7)
+})
 test.run()

package/all/be_memo_pair/index.d.ts

@@ -1,4 +1,4 @@
-import type { Be, be_config_T, ctx__be_T, ctx__get_T, Ctx_wide_T } from '../be_/index.js'
+import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, Ctx_wide_T } from '../be_/index.js'
 import type { memo_T, sig_T } from '../rmemo/index.js'
 export declare function be_memo_pair_<
 	val_T,
@@ -13,7 +13,34 @@ export declare function be_memo_pair_<
 	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
 >(
 	rmemo__new:(ctx:ctx_T, memo:sig_T<val_T, E>)=>val_T,
-	config?:be_config_T
+	...config:be_config_arg_a_T<ns_T>
+):be_memo_pair_T<val_T, ns_T, E, ctx_T>
+export declare function ns_be_memo_pair_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_memo_pair_T<val_T, ns_T, E, ctx_T>
+export declare function id_be_memo_pair_<
+	val_T,
+	E = unknown,
+	ctx_T extends Ctx_wide_T<''> = Ctx_wide_T<''>,
+>(
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_memo_pair_T<val_T, '', E, ctx_T>
+export declare function ns_id_be_memo_pair_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
 ):be_memo_pair_T<val_T, ns_T, E, ctx_T>
 export type be_memo_pair_T<
 	val_T,

package/all/be_memo_pair/index.js

@@ -11,7 +11,7 @@ import { memo_ } from '../rmemo/index.js'
  */
 export function be_memo_pair_(
 	be_OR_val__new,
-	config
+	config,
 ) {
 	let add_def_a = []
 	/** @type {Be} */
@@ -20,8 +20,10 @@ export function be_memo_pair_(
 			? be_OR_val__new
 			: be_(ctx=>
 				add_def_a.reduce(
-					(memo, add_def)=>memo.add((...arg_a)=>add_def(ctx, ...arg_a)),
-					memo_(memo=>be_OR_val__new(ctx, memo))),
+					(memo, add_def)=>
+						memo.add((...arg_a)=>add_def(ctx, ...arg_a)),
+					memo_(
+						memo=>be_OR_val__new(ctx, memo))),
 			config)
 	let be_memo_pair = [
 		be,
@@ -36,3 +38,41 @@ export function be_memo_pair_(
 	}
 	return be_memo_pair
 }
+/**
+ * @param {string}ns
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_memo_pair_T}
+ * @private
+ */
+export function ns_be_memo_pair_(
+	ns,
+	val__new
+) {
+	return be_memo_pair_(val__new, { ns })
+}
+/**
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_memo_pair_T}
+ * @private
+ */
+export function id_be_memo_pair_(
+	id,
+	val__new
+) {
+	return be_memo_pair_(val__new, { id })
+}
+/**
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_memo_pair_T}
+ * @private
+ */
+export function ns_id_be_memo_pair_(
+	ns,
+	id,
+	val__new
+) {
+	return be_memo_pair_(val__new, { ns, id })
+}

package/all/be_memo_pair/index.test.ts

@@ -5,7 +5,7 @@ import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { memo_, type memo_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
-import { be_memo_pair_ } from './index.js'
+import { be_memo_pair_, id_be_memo_pair_, ns_be_memo_pair_, ns_id_be_memo_pair_ } from './index.js'
 test('be_memo_pair_', ()=>{
 	const [
 		,
@@ -36,7 +36,7 @@ test('be_memo_pair_', ()=>{
 	equal(foobar_(ctx), 3)
 	equal(foobar$_(ctx).count, 2)
 })
-test('be_memo_pair_|+id|+ns|+oninit|+add', ()=>{
+test('be_memo_pair_|+id|+ns|+add', ()=>{
 	const ctx = ns_ctx__new('test_ns')
 	let add_count = 0
 	const [
@@ -149,4 +149,132 @@ test('be_memo_pair_|be', ()=>{
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 1)
 })
+test('ns_be_memo_pair_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+	] = ns_be_memo_pair_(
+		'test_ns',
+		ctx=>base_(ctx) + 1,
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 5)
+})
+test('id_be_memo_pair_', ()=>{
+	const ctx = ctx__new()
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1)
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+	] = id_be_memo_pair_(
+		'foobar',
+		ctx=>base_(ctx) + 1
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal((ctx.s[''].get('foobar')![0] as memo_T<number>)._, 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
+	base__set(ctx, 2)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal((ctx.s[''].get('foobar')![0] as memo_T<number>)._, 3)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 5)
+})
+test('ns_id_be_memo_pair_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+	] = ns_id_be_memo_pair_(
+		'test_ns',
+		'foobar',
+		ctx=>base_(ctx) + 1
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal((ctx.s.test_ns.get('foobar')![0] as memo_T<number>)._, 3)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 5)
+})
 test.run()

package/all/be_memosig_triple/index.d.ts

@@ -1,4 +1,4 @@
-import type { Be, be_config_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T } from '../be_/index.js'
+import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T } from '../be_/index.js'
 import type { sig_T } from '../rmemo/index.js'
 export declare function be_memosig_triple_<
 	val_T,
@@ -13,7 +13,34 @@ export declare function be_memosig_triple_<
 	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
 >(
 	rmemo__new:(ctx:ctx_T, memosig:sig_T<val_T, E>)=>val_T,
-	config?:be_config_T<ns_T>
+	...config:be_config_arg_a_T<ns_T>
+):be_memosig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function ns_be_memosig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_memosig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function id_be_memosig_triple_<
+	val_T,
+	E = unknown,
+	ctx_T extends Ctx_wide_T<''> = Ctx_wide_T<''>,
+>(
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_memosig_triple_T<val_T, '', E, ctx_T>
+export declare function ns_id_be_memosig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
 ):be_memosig_triple_T<val_T, ns_T, E, ctx_T>
 export type be_memosig_triple_T<
 	val_T,

package/all/be_memosig_triple/index.js

@@ -2,5 +2,10 @@
 /// <reference types="../be_sig_triple/index.d.ts" />
 /// <reference types="../rmemo/index.d.ts" />
 /// <reference types="./index.d.ts" />
-import { be_memo_pair_ } from '../be_memo_pair/index.js'
-export { be_memo_pair_ as be_memosig_triple_ }
+import { be_memo_pair_, id_be_memo_pair_, ns_be_memo_pair_, ns_id_be_memo_pair_ } from '../be_memo_pair/index.js'
+export {
+	be_memo_pair_ as be_memosig_triple_,
+	ns_be_memo_pair_ as ns_be_memosig_triple_,
+	id_be_memo_pair_ as id_be_memosig_triple_,
+	ns_id_be_memo_pair_ as ns_id_be_memosig_triple_,
+}

package/all/be_memosig_triple/index.test.ts

@@ -5,7 +5,7 @@ import { be_sig_triple_ } from '../be_sig_triple/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { memo_, memosig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
-import { be_memosig_triple_ } from './index.js'
+import { be_memosig_triple_, id_be_memosig_triple_, ns_be_memosig_triple_, ns_id_be_memosig_triple_ } from './index.js'
 test('be_memosig_triple_', ()=>{
 	const [
 		,
@@ -60,7 +60,7 @@ test('be_memosig_triple_|+id|+ns', ()=>{
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_memosig_triple_(
+	] = be_memosig_triple_<number, 'test_ns'>(
 		ctx=>{
 			/* eslint-disable @typescript-eslint/no-unused-vars */
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
@@ -154,4 +154,174 @@ test('be_memosig_triple_|+be', ()=>{
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 3)
 })
+test('ns_be_memosig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_be_memosig_triple_(
+		'test_ns',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		}
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(add_count, 3)
+	equal(add_dep_(ctx), 6)
+})
+test('id_be_memosig_triple_', ()=>{
+	const ctx = ctx__new()
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1)
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = id_be_memosig_triple_(
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		}
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ctx, 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(add_count, 3)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 3)
+	equal(add_dep_(ctx), 6)
+})
+test('ns_id_be_memosig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1,
+		{ ns: 'test_ns' })
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = be_sig_triple_(()=>1,
+		{ ns: 'test_ns' })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_id_be_memosig_triple_(
+		'test_ns',
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return base_(ctx) + 1
+		},
+	).add((ctx, foobar$)=>memo_(()=>{
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+		/* eslint-enable @typescript-eslint/no-unused-vars */
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 1)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_dep_(ctx), 3)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 5)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 5)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 5)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 3)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(add_count, 3)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 3)
+	equal(add_dep_(ctx), 6)
+})
 test.run()

package/all/be_sig_triple/index.d.ts

@@ -1,4 +1,4 @@
-import type { Be, be_config_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T } from '../be_/index.js'
+import type { Be, be_config_arg_a_T, ctx__be_T, ctx__get_T, ctx__set_T, Ctx_wide_T } from '../be_/index.js'
 import type { sig_T } from '../rmemo/index.js'
 export declare function be_sig_triple_<
 	val_T,
@@ -13,7 +13,34 @@ export declare function be_sig_triple_<
 	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
 >(
 	val__new:(ctx:ctx_T)=>val_T,
-	config?:be_config_T<ns_T>
+	...config:be_config_arg_a_T<ns_T>
+):be_sig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function ns_be_sig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_sig_triple_T<val_T, ns_T, E, ctx_T>
+export declare function id_be_sig_triple_<
+	val_T,
+	E = unknown,
+	ctx_T extends Ctx_wide_T<''> = Ctx_wide_T<''>,
+>(
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
+):be_sig_triple_T<val_T, '', E, ctx_T>
+export declare function ns_id_be_sig_triple_<
+	val_T,
+	ns_T extends string = '',
+	E = unknown,
+	ctx_T extends Ctx_wide_T<ns_T> = Ctx_wide_T<ns_T>,
+>(
+	ns:ns_T,
+	id:string,
+	val__new:(ctx:ctx_T)=>val_T,
 ):be_sig_triple_T<val_T, ns_T, E, ctx_T>
 export type be_sig_triple_T<
 	val_T,

package/all/be_sig_triple/index.js

@@ -36,3 +36,41 @@ export function be_sig_triple_(
 	}
 	return be_sig_triple
 }
+/**
+ * @param {string}ns
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_sig_triple_T}
+ * @private
+ */
+export function ns_be_sig_triple_(
+	ns,
+	val__new
+) {
+	return be_sig_triple_(val__new, { ns })
+}
+/**
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_sig_triple_T}
+ * @private
+ */
+export function id_be_sig_triple_(
+	id,
+	val__new
+) {
+	return be_sig_triple_(val__new, { id })
+}
+/**
+ * @param {string}ns
+ * @param {string}id
+ * @param {be__val__new_T<unknown>}val__new
+ * @returns {be_sig_triple_T}
+ * @private
+ */
+export function ns_id_be_sig_triple_(
+	ns,
+	id,
+	val__new
+) {
+	return be_sig_triple_(val__new, { ns, id })
+}

package/all/be_sig_triple/index.test.ts

@@ -4,7 +4,7 @@ import { be_, type Ctx_wide_T } from '../be_/index.js'
 import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { memo_, sig_, type sig_T } from '../rmemo/index.js'
 import type { Equal, Expect } from '../test/index.js'
-import { be_sig_triple_ } from './index.js'
+import { be_sig_triple_, id_be_sig_triple_, ns_be_sig_triple_, ns_id_be_sig_triple_ } from './index.js'
 test('be_sig_triple_', ()=>{
 	const [
 		foobar$_,
@@ -24,7 +24,7 @@ test('be_sig_triple_', ()=>{
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
 })
-test('be_sig_triple_|+id|+ns', ()=>{
+test('be_sig_triple_|+id|+ns|+add', ()=>{
 	const ctx = ns_ctx__new('test_ns')
 	let add_count = 0
 	const [
@@ -72,13 +72,13 @@ test('be_sig_triple_|+be', ()=>{
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_sig_triple_<number, 'test_ns', { custom: string }>(
+	] = be_sig_triple_<number, 'test_ns', { custom:string }>(
 		be_(ctx=>{
 			/* eslint-disable @typescript-eslint/no-unused-vars */
 			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
 			/* eslint-enable @typescript-eslint/no-unused-vars */
 			const foobar$ =
-				sig_<number, { custom: string }>(
+				sig_<number, { custom:string }>(
 					1
 				).add(()=>add_count++)
 			foobar$.custom = 'custom-val'
@@ -101,4 +101,128 @@ test('be_sig_triple_|+be', ()=>{
 	equal(foobar$_(ctx).custom, 'custom-val')
 	equal(add_count, 1)
 })
+test('ns_be_sig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = ns_be_sig_triple_(
+		'test_ns',
+		()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_be_sig_triple_(
+		'test_ns',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return 1
+		}
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 1)
+	equal(foobar$_(ctx)._, 1)
+	equal(foobar_(ctx), 1)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 2)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 4)
+})
+test('id_be_sig_triple_', ()=>{
+	const ctx = ctx__new()
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = id_be_sig_triple_(
+		'add_dep',
+		()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = id_be_sig_triple_(
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<''>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return 1
+		}
+	).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ctx)._, 1)
+	equal(foobar_(ctx), 1)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 2)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 1)
+	foobar__set(ctx, 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal((ctx.s[''].get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 4)
+})
+test('ns_id_be_sig_triple_', ()=>{
+	const ctx = ns_ctx__new('test_ns')
+	let add_count = 0
+	const [
+		,
+		add_dep_,
+		add_dep__set
+	] = ns_id_be_sig_triple_(
+		'test_ns',
+		'app_dep',
+		()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = ns_id_be_sig_triple_(
+		'test_ns',
+		'foobar',
+		ctx=>{
+			/* eslint-disable @typescript-eslint/no-unused-vars */
+			type test_ctx = Expect<Equal<typeof ctx, Ctx_wide_T<'test_ns'>>>
+			/* eslint-enable @typescript-eslint/no-unused-vars */
+			return 1
+		}).add((ctx, foobar$)=>memo_(()=>{
+		add_count++
+		add_dep__set(ctx, add_count + foobar$())
+	}))
+	equal(add_count, 0)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 1)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 1)
+	equal(foobar$_(ctx)._, 1)
+	equal(foobar_(ctx), 1)
+	equal(add_count, 1)
+	equal(add_dep_(ctx), 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 1)
+	foobar__set(ns_ctx__new(ctx__new(), ctx), 2)
+	equal(foobar$_(ns_ctx__new(ctx__new(), ctx))._, 2)
+	equal(foobar_(ns_ctx__new(ctx__new(), ctx)), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal((ctx.s.test_ns.get('foobar')![0] as sig_T<number>)._, 2)
+	equal(add_count, 2)
+	equal(add_dep_(ctx), 4)
+})
 test.run()

package/all/ctx/index.d.ts

@@ -2,8 +2,12 @@ import type { Ctx } from '../be_/index.js'
 import type { TupleToUnion } from '../tuple/index.js'
 export declare function ctx__new():Ctx<''>
 export { ctx__new as ctx_ }
-export declare function ns_ctx__new<ns0_T extends string|Ctx, ns_a_T extends (string|Ctx)[]>(
-	ns0:ns0_T, ...ns_a:ns_a_T
+export declare function ns_ctx__new<
+	ns0_T extends string|Ctx,
+	ns_a_T extends (string|Ctx)[]
+>(
+	ns0:ns0_T,
+	...ns_a:ns_a_T
 ):Ctx<Exclude<TupleToUnion<ns_a__flat_T<[ns0_T]>>|TupleToUnion<ns_a__flat_T<ns_a_T>>, undefined>>
 export { ns_ctx__new as ns_ctx_ }
 export declare function is_ctx_(val:unknown):boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "5.23.0",
+  "version": "5.25.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -188,14 +188,14 @@
       "import": {
         "./be": "{ be_, ctx_, ns_ctx_ }"
       },
-      "limit": "190 B"
+      "limit": "191 B"
     },
     {
       "name": "be_ ctx_ ns_ctx_",
       "import": {
         "./be": "{ be_, ctx_, ns_ctx_ }"
       },
-      "limit": "190 B"
+      "limit": "191 B"
     },
     {
       "name": "memo_",
@@ -223,7 +223,7 @@
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_, be_memo_pair_, be_sig_triple_ }"
       },
-      "limit": "576 B"
+      "limit": "570 B"
     },
     {
       "name": "uuid",