@rootintf/protocol-subverseinfo 2.0.1-api.4 → 2.1.1-api.5

package/dist/subverseinfo.es.mjs

@@ -85,8 +85,8 @@ function validate19(data, { instancePath = "", parentData, parentDataProperty, r
             if (valid0) {
                 if (data.subverse_info !== undefined) {
                     const _errs9 = errors;
-                    if ("4" !== data.subverse_info) {
-                        validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
+                    if ("5" !== data.subverse_info) {
+                        validate19.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
                         return false;
                     }
                     var valid0 = _errs9 === errors;
@@ -108,7 +108,7 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
     evaluated0.items = undefined;
-} {
+} const _errs2 = errors; if (errors === _errs2) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
         let missing0;
         if (((data.uri === undefined) && (missing0 = "uri")) || ((data.name === undefined) && (missing0 = "name"))) {
@@ -146,7 +146,7 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
         validate21.errors = [{ instancePath, schemaPath: "definitions#/definitions/unique-id/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
         return false;
     }
-} {
+} if (errors === 0) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
         if (data.favicon !== undefined) {
             const _errs8 = errors;
@@ -163,25 +163,99 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.hyperport !== undefined) {
                 let data3 = data.hyperport;
                 const _errs10 = errors;
-                {
+                const _errs12 = errors;
+                let valid5 = false;
+                let passing0 = null;
+                const _errs13 = errors;
+                if (typeof data3 !== "string") {
+                    const err0 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err0];
+                    }
+                    else {
+                        vErrors.push(err0);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs13 === errors;
+                if (_valid0) {
+                    valid5 = true;
+                    passing0 = 0;
+                }
+                const _errs15 = errors;
+                if (errors === _errs15) {
                     if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
                         let missing1;
                         if (((data3.uri === undefined) && (missing1 = "uri")) || ((data3.port === undefined) && (missing1 = "port"))) {
-                            validate21.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
-                            return false;
+                            const err1 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                            if (vErrors === null) {
+                                vErrors = [err1];
+                            }
+                            else {
+                                vErrors.push(err1);
+                            }
+                            errors++;
                         }
                         else {
                             if (data3.uri !== undefined) {
                                 if (typeof data3.uri !== "string") {
-                                    validate21.errors = [{ instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                    return false;
+                                    const err2 = { instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/oneOf/1/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                    if (vErrors === null) {
+                                        vErrors = [err2];
+                                    }
+                                    else {
+                                        vErrors.push(err2);
+                                    }
+                                    errors++;
                                 }
                             }
                         }
                     }
                     else {
-                        validate21.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                        return false;
+                        const err3 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                            vErrors = [err3];
+                        }
+                        else {
+                            vErrors.push(err3);
+                        }
+                        errors++;
+                    }
+                }
+                var _valid0 = _errs15 === errors;
+                if (_valid0 && valid5) {
+                    valid5 = false;
+                    passing0 = [passing0, 1];
+                }
+                else {
+                    if (_valid0) {
+                        valid5 = true;
+                        passing0 = 1;
+                        var props0 = {};
+                        props0.uri = true;
+                    }
+                }
+                if (!valid5) {
+                    const err4 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                    validate21.errors = vErrors;
+                    return false;
+                }
+                else {
+                    errors = _errs12;
+                    if (vErrors !== null) {
+                        if (_errs12) {
+                            vErrors.length = _errs12;
+                        }
+                        else {
+                            vErrors = null;
+                        }
                     }
                 }
                 var valid3 = _errs10 === errors;
@@ -192,12 +266,12 @@ function validate21(data, { instancePath = "", parentData, parentDataProperty, r
             if (valid3) {
                 if (data.info !== undefined) {
                     let data5 = data.info;
-                    const _errs15 = errors;
+                    const _errs19 = errors;
                     if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
                         validate21.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
                         return false;
                     }
-                    var valid3 = _errs15 === errors;
+                    var valid3 = _errs19 === errors;
                 }
                 else {
                     var valid3 = true;
@@ -215,7 +289,7 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
     evaluated0.props = undefined;
 } if (evaluated0.dynamicItems) {
     evaluated0.items = undefined;
-} {
+} const _errs2 = errors; if (errors === _errs2) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
         let missing0;
         if (((data.uri === undefined) && (missing0 = "uri")) || ((data.name === undefined) && (missing0 = "name"))) {
@@ -253,7 +327,7 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
         validate24.errors = [{ instancePath, schemaPath: "definitions#/definitions/unique-id/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
         return false;
     }
-} {
+} if (errors === 0) {
     if (data && typeof data == "object" && !Array.isArray(data)) {
         if (data.favicon !== undefined) {
             const _errs8 = errors;
@@ -270,25 +344,99 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
             if (data.hyperport !== undefined) {
                 let data3 = data.hyperport;
                 const _errs10 = errors;
-                {
+                const _errs12 = errors;
+                let valid5 = false;
+                let passing0 = null;
+                const _errs13 = errors;
+                if (typeof data3 !== "string") {
+                    const err0 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/0/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                    if (vErrors === null) {
+                        vErrors = [err0];
+                    }
+                    else {
+                        vErrors.push(err0);
+                    }
+                    errors++;
+                }
+                var _valid0 = _errs13 === errors;
+                if (_valid0) {
+                    valid5 = true;
+                    passing0 = 0;
+                }
+                const _errs15 = errors;
+                if (errors === _errs15) {
                     if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
                         let missing1;
                         if (((data3.uri === undefined) && (missing1 = "uri")) || ((data3.port === undefined) && (missing1 = "port"))) {
-                            validate24.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" }];
-                            return false;
+                            const err1 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/required", keyword: "required", params: { missingProperty: missing1 }, message: "must have required property '" + missing1 + "'" };
+                            if (vErrors === null) {
+                                vErrors = [err1];
+                            }
+                            else {
+                                vErrors.push(err1);
+                            }
+                            errors++;
                         }
                         else {
                             if (data3.uri !== undefined) {
                                 if (typeof data3.uri !== "string") {
-                                    validate24.errors = [{ instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" }];
-                                    return false;
+                                    const err2 = { instancePath: instancePath + "/hyperport/uri", schemaPath: "definitions#/definitions/hyperport/oneOf/1/properties/uri/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                                    if (vErrors === null) {
+                                        vErrors = [err2];
+                                    }
+                                    else {
+                                        vErrors.push(err2);
+                                    }
+                                    errors++;
                                 }
                             }
                         }
                     }
                     else {
-                        validate24.errors = [{ instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
-                        return false;
+                        const err3 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf/1/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                            vErrors = [err3];
+                        }
+                        else {
+                            vErrors.push(err3);
+                        }
+                        errors++;
+                    }
+                }
+                var _valid0 = _errs15 === errors;
+                if (_valid0 && valid5) {
+                    valid5 = false;
+                    passing0 = [passing0, 1];
+                }
+                else {
+                    if (_valid0) {
+                        valid5 = true;
+                        passing0 = 1;
+                        var props0 = {};
+                        props0.uri = true;
+                    }
+                }
+                if (!valid5) {
+                    const err4 = { instancePath: instancePath + "/hyperport", schemaPath: "definitions#/definitions/hyperport/oneOf", keyword: "oneOf", params: { passingSchemas: passing0 }, message: "must match exactly one schema in oneOf" };
+                    if (vErrors === null) {
+                        vErrors = [err4];
+                    }
+                    else {
+                        vErrors.push(err4);
+                    }
+                    errors++;
+                    validate24.errors = vErrors;
+                    return false;
+                }
+                else {
+                    errors = _errs12;
+                    if (vErrors !== null) {
+                        if (_errs12) {
+                            vErrors.length = _errs12;
+                        }
+                        else {
+                            vErrors = null;
+                        }
                     }
                 }
                 var valid3 = _errs10 === errors;
@@ -299,12 +447,12 @@ function validate24(data, { instancePath = "", parentData, parentDataProperty, r
             if (valid3) {
                 if (data.info !== undefined) {
                     let data5 = data.info;
-                    const _errs15 = errors;
+                    const _errs19 = errors;
                     if (!(data5 && typeof data5 == "object" && !Array.isArray(data5))) {
                         validate24.errors = [{ instancePath: instancePath + "/info", schemaPath: "definitions#/definitions/info/type", keyword: "type", params: { type: "object" }, message: "must be object" }];
                         return false;
                     }
-                    var valid3 = _errs15 === errors;
+                    var valid3 = _errs19 === errors;
                 }
                 else {
                     var valid3 = true;
@@ -703,8 +851,8 @@ function validate20(data, { instancePath = "", parentData, parentDataProperty, r
             if (valid0) {
                 if (data.subverse_info !== undefined) {
                     const _errs42 = errors;
-                    if ("4" !== data.subverse_info) {
-                        validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
+                    if ("5" !== data.subverse_info) {
+                        validate20.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
                         return false;
                     }
                     var valid0 = _errs42 === errors;
@@ -1100,8 +1248,8 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
             if (valid0) {
                 if (data.subverse_info !== undefined) {
                     const _errs44 = errors;
-                    if ("4" !== data.subverse_info) {
-                        validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "4" }, message: "must be equal to constant" }];
+                    if ("5" !== data.subverse_info) {
+                        validate27.errors = [{ instancePath: instancePath + "/subverse_info", schemaPath: "definitions#/definitions/_v/const", keyword: "const", params: { allowedValue: "5" }, message: "must be equal to constant" }];
                         return false;
                     }
                     var valid0 = _errs44 === errors;
@@ -1119,122 +1267,407 @@ function validate27(data, { instancePath = "", parentData, parentDataProperty, r
 } validate27.errors = vErrors; return errors === 0; }
 validate27.evaluated = { "props": { "expanse": true, "subverse_info": true }, "dynamicProps": false, "dynamicItems": false };
 
+// https://stackoverflow.com/questions/4602141/variable-name-as-a-string-in-javascript
 // console.log('OUT', __name({variableName}) );
-
-
+//-------------------------------------------------------------------------------------------------
+function l_length_(obj_labels) {
+    if (!obj_labels || typeof obj_labels !== 'object')
+        throw new Error('obj_labels must be an object');
+    const obj_1label = Object.values(obj_labels);
+    if (!obj_1label.every(v => typeof v === 'number' && Number.isFinite(v)))
+        throw new Error('All values must be finite numbers');
+    const labels = Object.values(obj_labels);
+    if (labels.length === 0)
+        return 1; // Empty object case, start at 1
+    const value_max = Math.max(...labels);
+    if (value_max <= 0)
+        return 1;
+    const bit_highest = Math.floor(Math.log2(value_max));
+    return 1 << (bit_highest + 1);
+}
+function l_array_(arr_labels, start = 1) {
+    if (!Array.isArray(arr_labels))
+        throw new Error('arr_labels must be an array');
+    if (!Number.isSafeInteger(start) || start < 0)
+        throw new Error('start must be a safe, non-negative integer');
+    return Object.freeze(arr_labels.reduce((acc, key, index) => {
+        acc[key] = start << index;
+        return acc;
+    }, {}));
+}
+function l_concat_(obj_labels, arg) {
+    if (!obj_labels || typeof obj_labels !== 'object')
+        throw new Error('obj_labels must be an object');
+    const obj_1label = Object.values(obj_labels);
+    if (!obj_1label.every(v => typeof v === 'number' && Number.isFinite(v)))
+        throw new Error('All values must be finite numbers');
+    if (!arg || (typeof arg !== 'object' && !Array.isArray(arg)))
+        throw new Error('arg must be an object or array');
+    if (Array.isArray(arg)) {
+        const len = l_length_(obj_labels);
+        const arr_labels_new = l_array_(arg, len);
+        return l_concat_(obj_labels, arr_labels_new);
+    }
+    const next_pos = l_length_(obj_labels);
+    const arg_entries = Object.entries(arg);
+    const result = Object.create(null);
+    Object.entries(obj_labels).forEach(([k, v]) => {
+        if (k !== '__proto__' && k !== 'constructor')
+            result[k] = v;
+    });
+    let min_arg = Infinity;
+    for (const [, value] of arg_entries) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            continue; // Skip non-numeric
+        if (value > 0 && value < min_arg)
+            min_arg = value;
+    }
+    // Shift only if min_arg is less than next_pos
+    const shift = min_arg === Infinity || min_arg >= next_pos
+        ? 0
+        : Math.floor(Math.log2(next_pos / min_arg));
+    for (const [key, value] of arg_entries) {
+        if (!(key in result)) {
+            result[key] = value === 0 ? 0 : value << shift;
+        }
+    }
+    return Object.freeze(result);
+}
+function l_merge_(obj_labels1, obj_labels2) {
+    if (!obj_labels1 || typeof obj_labels1 !== 'object')
+        throw new Error('obj_labels must be an object');
+    const obj_1label1 = Object.values(obj_labels1);
+    if (!obj_1label1.every(v => typeof v === 'number' && Number.isFinite(v)))
+        throw new Error('All values must be finite numbers');
+    if (!obj_labels2 || typeof obj_labels2 !== 'object')
+        throw new Error('obj_labels must be an object');
+    const obj_1label2 = Object.values(obj_labels2);
+    if (!obj_1label2.every(v => typeof v === 'number' && Number.isFinite(v)))
+        throw new Error('All values must be finite numbers');
+    const result = Object.create(null);
+    Object.entries(obj_labels1).forEach(([k, v]) => {
+        if (k !== '__proto__' && k !== 'constructor')
+            result[k] = v;
+    });
+    const set_values = new Set(Object.values(obj_labels1)); // Track all used bit values
+    // Find the highest bit position to start shifting from if needed
+    const value_highest = Math.max(0, ...Array.from(set_values));
+    let next_shift = value_highest ? Math.floor(Math.log2(value_highest)) + 1 : 0;
+    // Process second set
+    for (const [key, value] of Object.entries(obj_labels2)) {
+        if (key in result) {
+            // Same key: Values must match
+            if (result[key] !== value) {
+                throw new Error(`Key '${key}' has conflicting values: ${result[key]} (obj_labels1) vs ${value} (obj_labels2)`);
+            }
+            // No action needed if values match, already in result
+        }
+        else {
+            let maxIterations = 1000;
+            // New key: Add if value is unique, otherwise shift
+            let value_new = value;
+            while (set_values.has(value_new) && maxIterations--) {
+                value_new = 1 << next_shift++;
+            }
+            if (maxIterations <= 0)
+                throw new Error('Too many collisions in l_merge_');
+            result[key] = value_new;
+            set_values.add(value_new);
+        }
+    }
+    return Object.freeze(result);
+}
 function l_LL_(obj, x) {
-	if (! obj || typeof obj !== 'object') 
-		throw new Error('obj must be an object');
-	if (! Number.isSafeInteger(x) || x < 0) 
-		throw new Error('Shift value must be a safe, non-negative integer');
-
-	const obj_new= {};
-	for (const [k,v] of Object.entries(obj)) {
-		if (typeof v !== 'number' || ! Number.isFinite(v)) 
-			continue; // Skip non-numeric
-		obj_new[k] = v<<x;
-	}
-	return Object.freeze(obj_new);
+    if (!obj || typeof obj !== 'object')
+        throw new Error('obj must be an object');
+    if (!Number.isSafeInteger(x) || x < 0)
+        throw new Error('Shift value must be a safe, non-negative integer');
+    const obj_new = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (typeof v !== 'number' || !Number.isFinite(v))
+            continue; // Skip non-numeric
+        obj_new[k] = v << x;
+    }
+    return Object.freeze(obj_new);
 }
-
-//-------------------------------------------------------------------------------------------------
-
-function handler_default_( /* ... */ ) {
-	// https://stackoverflow.com/questions/18746440/passing-multiple-arguments-to-console-log
-	var args = Array.prototype.slice.call(arguments);
-	console.log.apply(console, args);
+function l_RR_(obj, x) {
+    if (!obj || typeof obj !== 'object')
+        throw new Error('obj must be an object');
+    if (!Number.isSafeInteger(x) || x < 0)
+        throw new Error('Shift value must be a safe, non-negative integer');
+    const obj_new = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (typeof v !== 'number' || !Number.isFinite(v))
+            continue; // Skip non-numeric
+        obj_new[k] = v >> x;
+    }
+    return Object.freeze(obj_new);
 }
-
 //-------------------------------------------------------------------------------------------------
-	
-function l_toBigInt_(obj_labels, obj, ignore= false) {
-    if (! obj_labels || typeof obj_labels !== 'object') 
-		throw new Error('obj_labels must be an object');
-    if (! obj || typeof obj !== 'object') 
-		throw new Error('obj must be an object');
-
-	let bigInt = BigInt(0);
-	for (const [k,v] of Object.entries(obj)) {
-		if ( ( ignore || v ) && obj_labels[k] !== undefined && typeof obj_labels[k] === 'number')
-			bigInt|= BigInt( obj_labels[k] );			
-		// console.log('0b'+ bigInt.toString(2) );
-	}
-	return bigInt;
+function handler_default_( /* ... */) {
+    // https://stackoverflow.com/questions/18746440/passing-multiple-arguments-to-console-log
+    var args = Array.prototype.slice.call(arguments);
+    console.log.apply(console, args);
+}
+function l_toBigInt_(obj_labels, obj, ignore = false) {
+    if (!obj_labels || typeof obj_labels !== 'object')
+        throw new Error('obj_labels must be an object');
+    if (!obj || typeof obj !== 'object')
+        throw new Error('obj must be an object');
+    let bigint_l = BigInt(0);
+    for (const [k, v] of Object.entries(obj)) {
+        if ((ignore || v) && obj_labels[k] !== undefined && typeof obj_labels[k] === 'number')
+            bigint_l |= BigInt(obj_labels[k]);
+        // console.log('0b'+ bigInt.toString(2) );
+    }
+    return bigint_l;
+}
+function lRef(initial) {
+    if (arguments.length === 0 || initial === undefined) {
+        return undefined;
+    }
+    let value = initial;
+    return {
+        get: () => value,
+        set: (newVal) => { value = newVal; }
+    };
+}
+/*
+const l_ = {
+    get VALIDATION() { return logr_.lref.get().VALIDATION; }
 }
 
-// console.log(l_toBigInt_({},{}))
-
-const LOGR = (function () {
-	let _instance; // Private variable to hold the single instance
+function createBitFlags(ref) {
+    // Create a proxy so that any property access computes the current bit
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            const positions = ref.get();           // get current { VALIDATION: n, ... }
+            const position = positions[prop];      // e.g., positions['VALIDATION']
 
-	function _create_instance() {
-		// Private state (replacing constructor properties)
-		let _handler_log = handler_default_;
-		let _obj_labels = undefined;
-		let _Bint_toggled = BigInt(0);
+            if (position === undefined) {
+                // Optional: warn or return 0 for unknown keys
+                console.warn(`Unknown bitflag key: ${String(prop)}`);
+                return 0;
+            }
 
-		function _log_fxn(nr_logged, argsFn /* args */) {
-			if ((BigInt(nr_logged) & _Bint_toggled) === BigInt(0))
-				return false;
+            return 0b1 << position;  // or 1 << position
+        },
 
-			const args = argsFn();
-			_handler_log.apply(this, args);
-			// _handler_log.apply(this, args);
-			return true;
-		}
+        // Optional: make Object.keys(l_) show the actual keys
+        ownKeys(target) {
+            return Object.keys(ref.get());
+        },
 
-		return {
-			set handler(fx) {
-				_handler_log = fx;
-			},
-			get handler() {
-				return _handler_log;
-			},
+        getOwnPropertyDescriptor(target, prop) {
+            return {
+                enumerable: true,
+                configurable: true,
+            };
+        }
+    });
+}
 
-			get labels() { return _obj_labels; },
-			set labels(obj) {
-				_obj_labels = obj;
-				_Bint_toggled = BigInt(0);
-			},
+type BitPositions = Record<string, number>;
 
-			// put= function(label, abbrv) {
-			// 	let name= __name(label);
-			// 	_labels[name]= label[name];
-			// 	console.log(_labels);
-			// }
+function createBitFlags<T extends BitPositions>(ref: { get: () => T }) {
+    return new Proxy({} as { [K in keyof T]: number }, {
+        get(target, prop: string | symbol) {
+            if (typeof prop !== 'string') return undefined;
+            const positions = ref.get();
+            const position = positions[prop as keyof T];
+            if (position === undefined) return 0;
+            return 1 << position;
+        },
+        ownKeys() {
+            return Object.keys(ref.get());
+        },
+        getOwnPropertyDescriptor() {
+            return { enumerable: true, configurable: true };
+        }
+    });
+}
+*/
+function create_Referenced_l_(ref) {
+    return new Proxy({}, {
+        get(target, prop) {
+            if (typeof prop !== 'string')
+                return undefined;
+            // if (prop === 'get') {
+            // 	return () => {
+            // 		const positions = ref.get();
+            // 		const result: Partial<Record<keyof T, number>> = {};
+            // 		for (const key in positions) {
+            // 			result[key as keyof T] = positions[key];
+            // 		}
+            // 		return result as Record<keyof T, number>;
+            // 	};
+            // }
+            if (prop === 'get')
+                return () => ref.get();
+            const positions = ref.get();
+            const value = positions[prop];
+            if (value === undefined)
+                return 0;
+            return value;
+        },
+        ownKeys() {
+            return Object.keys(ref.get());
+        },
+        getOwnPropertyDescriptor() {
+            return { enumerable: true, configurable: true };
+        }
+    });
+}
+const LOGR = (function () {
+    let _instance; // Private variable to hold the single instance
+    // Module-level state would work - but only when the module is loaded once. 
+    // Your bundler is currently bundling @knev/bitlogr into your distribution file, 
+    // creating a second copy. The Global Symbol approach would work around this, 
+    // but it's treating the symptom, not the cause. 
+    const GLOBAL_KEY = Symbol.for('@knev/bitlogr/LOGR');
+    // The real issue is your build configuration bundling dependencies that should remain external.
+    // rollup.config.mjs: external: ['@knev/bitlogr', 'uuid'], // Don't bundle these
+    function _create_instance() {
+        const _id = Math.random();
+        if (globalThis.LOGR_ENABLED ?? true)
+            console.log('creating LOGR instance:', _id);
+        // Private state (replacing constructor properties)
+        let _Bint_toggled = BigInt(0);
+        let _handler_log = handler_default_;
+        function _log_fxn(nr_logged, argsFn /* args */) {
+            // console.log('_log_fxn: ', BigInt(nr_logged), _Bint_toggled, (BigInt(nr_logged) & _Bint_toggled));
+            if ((BigInt(nr_logged) & _Bint_toggled) === BigInt(0))
+                return;
+            const args = argsFn();
+            _handler_log.apply(this, args);
+        }
+        return {
+            _id, // for testing
+            get handler() { return _handler_log; },
+            set handler(fx) {
+                _handler_log = fx;
+            },
+            get toggled() { return _Bint_toggled; },
+            // toggle(obj_labels, obj_toggled) {
+            // 	_Bint_toggled= l_toBigInt_(obj_labels, obj_toggled);
+            // },
+            toggle(labels, obj_toggled) {
+                const obj_labels = typeof labels?.get === 'function'
+                    ? labels.get()
+                    : labels;
+                // console.log('obj_labels', obj_labels)
+                _Bint_toggled = l_toBigInt_(obj_labels, obj_toggled);
+            },
+            // Core internal log function (exposed only to created loggers)
+            _log_fxn,
+            create(options = {}) {
+                // This constant will be replaced at build time
+                if (!(globalThis.LOGR_ENABLED ?? true)) {
+                    return {
+                        _obj_labels: undefined, // optional: keep shape compatible if needed
+                        log: () => { }, // does nothing
+                        raw: () => { }, // does nothing
+                    };
+                }
+                const _logger = {
+                    // _lref_labels: (options.arr_labels === undefined) ? undefined : lRef( l_array_(options.arr_labels) ),
+                    _lref_labels: (options.labels === undefined)
+                        ? undefined
+                        : lRef(options.labels),
+                    get l() {
+                        // Always create a fresh proxy pointing to the current labels
+                        return create_Referenced_l_({
+                            get: () => this._lref_labels?.get() || {}
+                        });
+                    },
+                    get lref() { return this._lref_labels; },
+                    set lref(lref_labels_new) {
+                        this._lref_labels = lref_labels_new;
+                    },
+                    log(nr_logged, argsFn) {
+                        // This constant will be replaced at build time
+                        if (!(globalThis.LOGR_ENABLED ?? true))
+                            return;
+                        _log_fxn.call(this, nr_logged, argsFn);
+                    },
+                    // Optional shorthand for common cases
+                    raw(...args) {
+                        _handler_log.apply(this, args);
+                    }
+                };
+                return _logger;
+            },
+        };
+    }
+    // Public interface
+    return {
+        get_instance() {
+            if (!(globalThis.LOGR_USE_GLOBAL_KEY ?? true)) {
+                if (!_instance)
+                    _instance = _create_instance(); // Lazy initialization
+                return _instance;
+            }
+            if (!globalThis[GLOBAL_KEY])
+                globalThis[GLOBAL_KEY] = _create_instance();
+            return globalThis[GLOBAL_KEY];
+        },
+        // For testing only - reset the singleton
+        _reset_for_testing() {
+            delete globalThis[GLOBAL_KEY];
+        }
+    };
+})();
 
-			get toggled() { return _Bint_toggled; },
-			set toggled(obj_toggled) {
-				_Bint_toggled= l_toBigInt_(_obj_labels, obj_toggled);
-			},
+var logr_es = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LOGR: LOGR,
+    _create_Referenced_l: create_Referenced_l_,
+    lRef: lRef,
+    l_LL: l_LL_,
+    l_RR: l_RR_,
+    l_array: l_array_,
+    l_concat: l_concat_,
+    l_length: l_length_,
+    l_merge: l_merge_
+});
 
-			log(nr_logged, argsFn) {
-				
-                return _log_fxn.call(this, nr_logged, argsFn); // Pass the thunk
-            }
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
 		};
-	}
-
-	// Public interface
-	return {
-		get_instance() {
-			if (!_instance) {
-				_instance = _create_instance(); // Lazy initialization
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
 			}
-			return _instance;
-		}
-	};
-
-})();
+		});
+	});
+	return a;
+}
 
 var jsonMsg_cjs = {};
 
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(logr_es);
+
 var hasRequiredJsonMsg_cjs;
 
 function requireJsonMsg_cjs () {
 	if (hasRequiredJsonMsg_cjs) return jsonMsg_cjs;
 	hasRequiredJsonMsg_cjs = 1;
 
+	var bitlogr = require$$0;
+
 	const schema_Msg = validate18;
 	function validate18(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) { let vErrors = null; let errors = 0; const evaluated0 = validate18.evaluated; if (evaluated0.dynamicProps) {
 	    evaluated0.props = undefined;
@@ -1404,105 +1837,12 @@ function requireJsonMsg_cjs () {
 	    return _v4(options);
 	}
 
-	// console.log('OUT', __name({variableName}) );
-
-
 	//-------------------------------------------------------------------------------------------------
-
-	function handler_default_( /* ... */ ) {
-		// https://stackoverflow.com/questions/18746440/passing-multiple-arguments-to-console-log
-		var args = Array.prototype.slice.call(arguments);
-		console.log.apply(console, args);
-	}
-
+	const LOGR_ = bitlogr.LOGR.get_instance();
+	const logr_ = LOGR_.create({ labels: bitlogr.l_array(['VALIDATION']) });
+	const l_ = logr_.l;
+	// console.log('File location:', import.meta.url, '[Implementation]');
 	//-------------------------------------------------------------------------------------------------
-		
-	function l_toBigInt_(obj_labels, obj, ignore= false) {
-	    if (! obj_labels || typeof obj_labels !== 'object') 
-			throw new Error('obj_labels must be an object');
-	    if (! obj || typeof obj !== 'object') 
-			throw new Error('obj must be an object');
-
-		let bigInt = BigInt(0);
-		for (const [k,v] of Object.entries(obj)) {
-			if ( ( ignore || v ) && obj_labels[k] !== undefined && typeof obj_labels[k] === 'number')
-				bigInt|= BigInt( obj_labels[k] );			
-			// console.log('0b'+ bigInt.toString(2) );
-		}
-		return bigInt;
-	}
-
-	// console.log(l_toBigInt_({},{}))
-
-	const LOGR = (function () {
-		let _instance; // Private variable to hold the single instance
-
-		function _create_instance() {
-			// Private state (replacing constructor properties)
-			let _handler_log = handler_default_;
-			let _obj_labels = undefined;
-			let _Bint_toggled = BigInt(0);
-
-			function _log_fxn(nr_logged, argsFn /* args */) {
-				if ((BigInt(nr_logged) & _Bint_toggled) === BigInt(0))
-					return false;
-
-				const args = argsFn();
-				_handler_log.apply(this, args);
-				// _handler_log.apply(this, args);
-				return true;
-			}
-
-			return {
-				set handler(fx) {
-					_handler_log = fx;
-				},
-				get handler() {
-					return _handler_log;
-				},
-
-				get labels() { return _obj_labels; },
-				set labels(obj) {
-					_obj_labels = obj;
-					_Bint_toggled = BigInt(0);
-				},
-
-				// put= function(label, abbrv) {
-				// 	let name= __name(label);
-				// 	_labels[name]= label[name];
-				// 	console.log(_labels);
-				// }
-
-				get toggled() { return _Bint_toggled; },
-				set toggled(obj_toggled) {
-					_Bint_toggled= l_toBigInt_(_obj_labels, obj_toggled);
-				},
-
-				log(nr_logged, argsFn) {
-					
-	                return _log_fxn.call(this, nr_logged, argsFn); // Pass the thunk
-	            }
-			};
-		}
-
-		// Public interface
-		return {
-			get_instance() {
-				if (!_instance) {
-					_instance = _create_instance(); // Lazy initialization
-				}
-				return _instance;
-			}
-		};
-
-	})();
-
-	let LOGR_ = LOGR.get_instance();
-	const log_ = LOGR_.log;
-	const l_ = {
-	    VALIDATION: 0b1 << 0,
-	};
-	LOGR_.labels = l_;
 	// TODO: use RFC3339 "timestamp"? https://ajv.js.org/json-type-definition.html
 	// "module" pattern to avoid "static" and "#" private : https://stackoverflow.com/a/1479341/298545
 	var JSON_Msg = (function () {
@@ -1517,7 +1857,7 @@ function requireJsonMsg_cjs () {
 	        validate: function (json) {
 	            const b_valid = schema_Msg(json);
 	            if (!b_valid)
-	                log_(l_.VALIDATION, () => ['JSON_Msg: validate: ', schema_Msg.errors]);
+	                logr_.log(l_.VALIDATION, () => ['JSON_Msg: validate: ', schema_Msg.errors]);
 	            return b_valid;
 	        },
 	        // TODO: requires a separate ajv module require, and JTD specific schema
@@ -1539,7 +1879,7 @@ function requireJsonMsg_cjs () {
 	                return false;
 	            const b_valid = schema_MsgEffect(json);
 	            if (!b_valid)
-	                log_(l_.VALIDATION, () => ['JSON_MsgEffect: validate: ', schema_MsgEffect.errors]);
+	                logr_.log(l_.VALIDATION, () => ['JSON_MsgEffect: validate: ', schema_MsgEffect.errors]);
 	            return b_valid;
 	        }
 	    };
@@ -1566,7 +1906,7 @@ function requireJsonMsg_cjs () {
 	                return false;
 	            const b_valid = schema_MsgAckEffect(json);
 	            if (!b_valid)
-	                log_(l_.VALIDATION, () => ['JSON_MsgAckEffect: validate: ', schema_MsgAckEffect.errors]);
+	                logr_.log(l_.VALIDATION, () => ['JSON_MsgAckEffect: validate: ', schema_MsgAckEffect.errors]);
 	            return b_valid;
 	        }
 	    };
@@ -1575,24 +1915,18 @@ function requireJsonMsg_cjs () {
 	jsonMsg_cjs.JSON_Msg = JSON_Msg;
 	jsonMsg_cjs.JSON_MsgAck = JSON_MsgAck;
 	jsonMsg_cjs.JSON_MsgEffect = JSON_MsgEffect;
-	jsonMsg_cjs.l = l_;
+	jsonMsg_cjs.logr = logr_;
 	return jsonMsg_cjs;
 }
 
 var jsonMsg_cjsExports = requireJsonMsg_cjs();
 
-let LOGR_ = LOGR.get_instance();
-const log_ = LOGR_.log;
-Object.assign(jsonMsg_cjsExports.l, l_LL_(jsonMsg_cjsExports.l, 2)); // VALIDATION : 4
-const l_ = {
-    VALIDATION: 0b1 << 2, //4
-};
-LOGR_.labels = l_;
-LOGR_.toggled = {
-// VALIDATION : true	
-};
-const kstr_VERSION = "4";
+const kstr_VERSION = "5";
 // TODO: use RFC3339 "timestamp"? https://ajv.js.org/json-type-definition.html
+//-------------------------------------------------------------------------------------------------
+LOGR.get_instance();
+const l_ = jsonMsg_cjsExports.logr.l;
+//-------------------------------------------------------------------------------------------------
 // const regex_IOI= new RegExp('\\bquery\\s*\\{\\s*IOI\\s*\\(\\s*pkg\\s*:\\s*"([^"]*)"\\s*\\)\\s*\\{.*heartbeat\\s*\\}\\s*\\}');
 var JSON_MsgSubverseInfo_query = (function () {
     return {
@@ -1605,7 +1939,7 @@ var JSON_MsgSubverseInfo_query = (function () {
             // if (! JSON_Msg.validate(json))
             // 	return false;
             if (!schema_SubverseInfo_query(json)) {
-                log_(l_.VALIDATION, () => ['schema_SubverseInfo_query_: validate: ', schema_SubverseInfo_query.errors]);
+                jsonMsg_cjsExports.logr.log(l_.VALIDATION, () => ['schema_SubverseInfo_query_: validate: ', schema_SubverseInfo_query.errors]);
                 return false;
             }
             // const str_graphql = json["discovery"]["graphql"];
@@ -1632,7 +1966,7 @@ var JSON_MsgSubverseInfo_subverse = (function () {
                 if (!JSON_MsgSubverseInfo_query.validate(json_msg._cause))
                     return false;
             if (!schema_SubverseInfo_subverse(json_msg)) {
-                log_(l_.VALIDATION, () => ['JSON_SubverseInfo_expanse: validate: ', schema_SubverseInfo_subverse.errors]);
+                jsonMsg_cjsExports.logr.log(l_.VALIDATION, () => ['JSON_SubverseInfo_expanse: validate: ', schema_SubverseInfo_subverse.errors]);
                 return false;
             }
             return true;
@@ -1653,7 +1987,7 @@ var JSON_MsgSubverseInfo_instances = (function () {
                 if (!JSON_MsgSubverseInfo_query.validate(json_msg._cause))
                     return false;
             if (!schema_SubverseInfo_instances(json_msg)) {
-                log_(l_.VALIDATION, () => ['JSON_SubverseInfo_instances: validate: ', schema_SubverseInfo_instances.errors]);
+                jsonMsg_cjsExports.logr.log(l_.VALIDATION, () => ['JSON_SubverseInfo_instances: validate: ', schema_SubverseInfo_instances.errors]);
                 return false;
             }
             return true;
@@ -1661,4 +1995,5 @@ var JSON_MsgSubverseInfo_instances = (function () {
     };
 })();
 
-export { JSON_MsgSubverseInfo_instances, JSON_MsgSubverseInfo_query, JSON_MsgSubverseInfo_subverse, l_ as l };
+var logr = jsonMsg_cjsExports.logr;
+export { JSON_MsgSubverseInfo_instances, JSON_MsgSubverseInfo_query, JSON_MsgSubverseInfo_subverse, logr };