querysub 0.466.0 → 0.468.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.466.0",
+  "version": "0.468.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/-h-path-value-serialize/PathValueSerializer.ts

@@ -12,6 +12,9 @@ import { setFlag } from "socket-function/require/compileFlags";
 
 import cbor from "cbor-x";
 import { atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites } from "../2-proxy/PathValueProxyWatcher";
+import { getOwnThreadId } from "../-a-auth/certs";
+
+const LAZY_INSTANCE_MARKER = Symbol("PathValueSerializer.lazyInstance");
 import { formatNumber, formatPercent, formatTime } from "socket-function/src/formatting/format";
 setFlag(require, "cbor-x", "allowclient", true);
 
@@ -989,11 +992,26 @@ class PathValueSerializer {
         // NOTE: Using an object makes garbage collection MUCH easier, basically eliminating leaks (and...
         //  it should be fairly fast? We create a Buffer anyways... which is probably a lot slower than
         //  creating an object).
-        let lazyInstance = { call_PathValueSerializer_getPathValue_toGetThisValue: true };
+        // The symbol marker is non-enumerable to JSON/cbor, so a round-tripped lazyInstance will be missing it —
+        //  lets the throw sites distinguish "stale ref / cross-instance" from "serialized through JSON".
+        let lazyInstance: { [k: string]: unknown } = {
+            call_PathValueSerializer_getPathValue_toGetThisValue: true,
+            lazyCreatedAt: Date.now(),
+            lazyCreatedByThreadId: getOwnThreadId(),
+        };
+        lazyInstance[LAZY_INSTANCE_MARKER as unknown as string] = true;
         this.lazyValues.set(lazyInstance, buf);
         return lazyInstance;
     }
 
+    private describeMissingLazy(pathValue: PathValue): string {
+        let value = pathValue.value as { [k: string]: unknown } | undefined;
+        let hasMarker = !!value && (value as { [k: symbol]: unknown })[LAZY_INSTANCE_MARKER] === true;
+        let createdAt = value && value.lazyCreatedAt;
+        let createdBy = value && value.lazyCreatedByThreadId;
+        return `Path: ${pathValue.path}, time: ${JSON.stringify(pathValue.time)}, currentThreadId: ${getOwnThreadId()}, hasSymbolMarker: ${hasMarker}, lazyCreatedAt: ${createdAt}, lazyCreatedByThreadId: ${createdBy}`;
+    }
+
     public getPathValue(pathValue: PathValue | undefined, noMutate?: "noMutate"): unknown {
         if (!pathValue) return undefined;
         if (pathValue.isValueLazy) {
@@ -1001,7 +1019,7 @@ class PathValueSerializer {
             if (!buffer) {
                 debugbreak(2);
                 debugger;
-                throw new Error(`(getPathValue) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+                throw new Error(`(getPathValue) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)}). ${this.describeMissingLazy(pathValue)}`);
             }
             let newValue = recursiveFreeze(cbor.decode(buffer));
             if (!noMutate && !pathValue.isValueLazy) {
@@ -1031,7 +1049,7 @@ class PathValueSerializer {
                 // NOTE: Did you pass a raw PathValue and then try to use PathValueSerializer with it?
                 //  - Instead you should pass a buffer serialized with pathValueSerializer.serialize and
                 //      deserialized with pathValueSerializer.deserialize.
-                throw new Error(`(getPathValueOrBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+                throw new Error(`(getPathValueOrBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)}). ${this.describeMissingLazy(pathValue)}`);
             }
             return buffer;
         }
@@ -1044,7 +1062,7 @@ class PathValueSerializer {
             if (!buffer) {
                 debugbreak(2);
                 debugger;
-                throw new Error(`(getBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+                throw new Error(`(getBuffer) Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)}). ${this.describeMissingLazy(pathValue)}`);
             }
             return buffer;
         }

package/src/diagnostics/StatWarning.tsx

@@ -27,9 +27,9 @@ export class StatWarning extends qreact.Component<{
                 <span>Threshold exceeded: {this.props.threshold}</span>
             </div>
             <div className={restClass}>
-                <span>{this.props.children}</span>
-                <span> -</span>
                 <span>{this.props.name}</span>
+                <span> -</span>
+                <span>{this.props.children}</span>
                 {actions.map(action =>
                     <div
                         className={css.button.pad2(6, 2).background("hsla(0, 0%, 100%, 0.15)")}

package/src/diagnostics/StatsHeader.tsx

@@ -40,7 +40,7 @@ type StatInfo = {
     isOverDiet: boolean;
 };
 
-export class StatsHeader extends qreact.Component<{ getStats: () => StatDefinition[] }> {
+export class StatsHeader extends qreact.Component<{ getStats: () => StatDefinition[]; onlyWarnings?: boolean }> {
     state = t.state({
         expanded: t.lookup({ open: t.booleanOptional }),
         nowTick: t.number,
@@ -190,6 +190,13 @@ export class StatsHeader extends qreact.Component<{ getStats: () => StatDefiniti
             info.isOverDiet && !(info.stat.category in this.state.expanded)
         );
 
+        if (this.props.onlyWarnings) {
+            if (activeWarnings.length === 0) return undefined;
+            return <div className={css.vbox(4)}>
+                {activeWarnings.map(info => this.renderWarning(info))}
+            </div>;
+        }
+
         return <div className={css.vbox(4)}>
             <div className={css.hbox(2).wrap}>
                 {categories.map(category => {

package/src/diagnostics/pathAuditer.ts

@@ -396,13 +396,16 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
     }
 
     if (valuesToRequest.length > 0) {
-        let receivedValues = await PathAuditerController.nodes[nodeId].getPathValues(valuesToRequest);
-        if (receivedValues.length > 0) {
-            validStateComputer.ingestValuesAndValidStates({
-                pathValues: receivedValues,
-                parentSyncs: [],
-                initialTriggers: { values: new Set(), parentPaths: new Set() },
-            });
+        let receivedBuffers = await PathAuditerController.nodes[nodeId].getPathValues(valuesToRequest);
+        if (receivedBuffers.length > 0) {
+            let receivedValues = await pathValueSerializer.deserialize(receivedBuffers);
+            if (receivedValues.length > 0) {
+                validStateComputer.ingestValuesAndValidStates({
+                    pathValues: receivedValues,
+                    parentSyncs: [],
+                    initialTriggers: { values: new Set(), parentPaths: new Set() },
+                });
+            }
         }
     }
 
@@ -456,7 +459,7 @@ class PathAuditerService {
         return results;
     }
 
-    public async getPathValues(requests: PathTimeRequest[]): Promise<PathValue[]> {
+    public async getPathValues(requests: PathTimeRequest[]): Promise<Buffer[]> {
         let results: PathValue[] = [];
         for (let request of requests) {
             let value = authorityStorage.getValueAtOrBeforeTime(request.path, request.time);
@@ -464,7 +467,8 @@ class PathAuditerService {
                 results.push(value);
             }
         }
-        return results;
+        if (results.length === 0) return [];
+        return await pathValueSerializer.serialize(results);
     }
 
     public async ingestPathValues(serializedValues: Buffer[]): Promise<void> {