querysub 0.465.0 → 0.467.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.465.0",
+  "version": "0.467.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/storage/diskCache2.ts

@@ -14,7 +14,12 @@ let requestPersist = lazy(() => {
     }
 });
 
-let existingDiskCaches = new Set<string>();
+type DiskCache = {
+    get(key: string): Promise<Buffer | undefined>;
+    set(key: string, value: Buffer): void;
+};
+
+let existingDiskCaches = new Map<string, DiskCache>();
 /** NOTE: Slower than diskCache for reading, but... less flakey, and faster at writing. ALSO,
  *      doesn't synchronously block, which diskCache does.
  */
@@ -24,10 +29,7 @@ export function bufferDiskCache(
         /** Default = 64MB */
         inMemoryLimit?: number;
     }
-): {
-    get(key: string): Promise<Buffer | undefined>;
-    set(key: string, value: Buffer): void;
-} {
+): DiskCache {
     if (isNode()) {
         return {
             get: async (key: string) => undefined,
@@ -37,10 +39,10 @@ export function bufferDiskCache(
     let { uniqueName } = config;
     const inMemoryLimit = config.inMemoryLimit ?? 64 * 1024 * 1024;
 
-    if (existingDiskCaches.has(uniqueName)) {
-        throw new Error(`Duplicate diskCache ${uniqueName}`);
+    let prev = existingDiskCaches.get(uniqueName);
+    if (prev) {
+        return prev;
     }
-    existingDiskCaches.add(uniqueName);
     uniqueName = "diskCache7_" + uniqueName;
 
     let totalBufferCacheSize = 0;
@@ -89,10 +91,12 @@ export function bufferDiskCache(
         await writeFile({ path, data });
     };
 
-    return {
+    let diskCache: DiskCache = {
         get: getDiskCached,
         set: (key, value) => logErrors(setDiskCached(key, value)),
     };
+    existingDiskCaches.set(uniqueName, diskCache);
+    return diskCache;
 }