querysub 0.406.0 → 0.408.0

package/src/3-path-functions/syncSchema.ts

@@ -21,6 +21,7 @@ import { getSpecFromModule } from "./pathFunctionLoader";
 import { isNode } from "typesafecss";
 import { LOCAL_DOMAIN } from "../0-path-value-core/PathRouter";
 import { createRoutingOverrideKey } from "../0-path-value-core/PathRouterRouteOverride";
+import { delay } from "socket-function/src/batching";
 
 // This is the the function id which should be used when creating the FunctionSpec (in order to load the module),
 //  to access the permissions in the schema.
@@ -286,7 +287,9 @@ type SyncSchemaResult<Schema> = {
 
 let prefixes: string[] = [];
 // ONLY used by the deploy process. Path value server is pretty much the only one who needs this, and they aren't including client-side code, and they definitely aren't updating client-side code, so it doesn't make sense to use this directly.
-export function getPrefixesForDeploy(): string[] {
+export async function getPrefixesForDeploy(): Promise<string[]> {
+    await new Promise(r => setImmediate(r));
+    await new Promise(r => setImmediate(r));
     return prefixes;
 }
 // Used for some old non syncSchema schema cases
@@ -302,7 +305,8 @@ export function syncSchema<Schema>(schema?: Schema2): SyncSchemaResult<Schema> {
         const domainName = config.domainName ?? getDomain();
 
         const data = () => functionSchema()[domainName].PathFunctionRunner[moduleId].Data;
-        let dataCached = lazy(() => data()) as () => Schema;
+        // NOTE: We used to cache this, but then they would cache the current database that's inside of the schema, which is dynamically set. So I don't think caching this really makes sense. We might be able to do some kind of intelligent cache where we check what the current database is and only reuse the cache if that's the same. 
+        let dataCached = (() => data()) as () => Schema;
 
         let fncs = { ...functions };
 

package/src/4-deploy/deployGetFunctionsInner.ts

@@ -94,7 +94,7 @@ async function main() {
         }
     }
 
-    for (let prefix of getPrefixesForDeploy()) {
+    for (let prefix of await getPrefixesForDeploy()) {
         console.log(`PREFIX:${prefix}`);
     }
 }

package/src/4-deploy/deployPrefixes.ts

@@ -0,0 +1,14 @@
+import { setShardPrefixes } from "../0-path-value-core/ShardPrefixes";
+import { getPrefixesForDeploy } from "../3-path-functions/syncSchema";
+import path from "path";
+
+async function main() {
+    let deployPath = path.resolve("./deploy.ts");
+    await import(deployPath);
+
+    let prefixes = await getPrefixesForDeploy();
+    await setShardPrefixes(prefixes);
+}
+
+main().catch(console.error).finally(() => process.exit());
+

package/src/4-deploy/edgeNodes.ts

@@ -273,7 +273,7 @@ async function updateEdgeNodesFile() {
     let liveHash = "";
     if (!noSyncing()) {
         liveHash = await Querysub.commitSynced(() => {
-            return deploySchema()[getDomain()].deploy.live.hash;
+            return String(deploySchema()[getDomain()].deploy.live.hash);
         });
     }
 

package/src/4-querysub/Querysub.ts

@@ -285,10 +285,10 @@ export class Querysub {
      */
     @measureFnc
     public static async optionalStartupWait() {
+        await authorityLookup.startSyncing();
         await measureBlock(async () => {
             await waitForFirstTimeSync();
         }, "waitForFirstTimeSync");
-        await authorityLookup.startSyncing();
     }
 
     public static createWatcher(watcher: (obj: SyncWatcher) => void, options?: Partial<WatcherOptions<unknown>>): {
@@ -714,6 +714,10 @@ export class Querysub {
         })();
     }
 
+    private static socketFunctionInit() {
+        SocketFunction.addGlobalHook(() => authorityLookup.startSyncing());
+    }
+
     private static hostCalled = false;
     private static afterBootImports: string[] = [];
     /** NOTE: Imports occur one at a time, after the "clientsideEntryPoint", with each import waiting for the previous to finish.
@@ -744,6 +748,7 @@ export class Querysub {
         sourceCheck?: MachineSourceCheck<any>;
     }) {
         console.log(`Hosting server with config: ${JSON.stringify(config)}`);
+        this.socketFunctionInit();
 
         if (isClient()) {
             throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead.`);
@@ -1021,6 +1026,8 @@ export class Querysub {
         RequireController.addMapGetModules(async (result, args) => {
             let configObj = args[2] as { signedIdentity: SignedIdentity | undefined } | undefined;
             if (!await isAllowedToSeeSource(configObj?.signedIdentity)) {
+                require("debugbreak")(2);
+                debugger;
                 await isAllowedToSeeSource(configObj?.signedIdentity);
                 //console.log(red(`Not allowed to see source`));
                 for (let [key, value] of Object.entries(result.modules)) {
@@ -1038,6 +1045,7 @@ export class Querysub {
             throw new Error(`--client processes cannot host a service. Either stop passing --client and keep the process on the network and trusted, or stop calling hostServer and call Querysub.configRootDiscoveryLocation instead.`);
         }
 
+        this.socketFunctionInit();
         await SocketFunction.mount({
             public: isPublic(),
             port,
@@ -1062,10 +1070,14 @@ export class Querysub {
          */
         endFraction?: number;
     }): (keyof T)[] {
-        if (!isNode()) {
-            console.warn(`keys() is unlikely to work clientside. If we need to emulate how the server does the filtering, we should add an additional function to help with that. But there are issues with how query sub proxies watches, which make proxying partial key watches too difficult. ALSO, this is mostly for watching very large data streams with dynamic sharding (in FunctionRunner), and so shouldn't be needed clientside (the application can handle filtering at a schema level if it really wants something similar to this).`);
-        }
+
         let { startFraction, endFraction } = config || {};
+        if ((startFraction === undefined) !== (endFraction === undefined)) {
+            throw new Error(`startFraction and endFraction must both be provided, or both be undefined. If you want to get all keys, don't provide startFraction and endFraction.`);
+        }
+        if (!isNode() && startFraction !== undefined && endFraction !== undefined) {
+            console.warn(`keys() with a range restriction is not supported clientside. It's too complicated for the proxy to handle it because the hashing depends on the authority server. You can synchronize all the keys client side, but you can't synchronize a restriction of the keys.`);
+        }
         if (startFraction === undefined || endFraction === undefined) {
             return Object.keys(obj);
         }
@@ -1297,6 +1309,7 @@ setImmediate(async () => {
     // Import, so it registers addStatPeriodic
     await import("../5-diagnostics/nodeMetadata");
     await import("../diagnostics/pathAuditer");
+    await import("../diagnostics/NodeConnectionsPage");
 });
 
 setImmediate(async () => {
@@ -1312,7 +1325,6 @@ registerGetCompressNetwork(() => Querysub.COMPRESS_NETWORK);
 
 import "../diagnostics/watchdog";
 import "../diagnostics/trackResources";
-import "../diagnostics/benchmark";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { getCountPerPaint } from "../functional/onNextPaint";
 import { addEpsilons } from "../bits";

package/src/4-querysub/QuerysubController.ts

@@ -2,7 +2,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { cache, lazy } from "socket-function/src/caching";
 import { appendToPathStr, getPathDepth, getPathStr1, getPathStr3 } from "../path";
 import { FunctionMetadata } from "../3-path-functions/syncSchema";
-import { RemoteWatcher } from "../1-path-client/RemoteWatcher";
+import { RemoteWatcher, remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
 import { atomic, proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
 import { CallSpec, DEPTH_TO_DATA, commitCall, debugCallSpec, functionSchema, getDevFunctionSpecFromCall } from "../3-path-functions/PathFunctionRunner";
@@ -200,6 +200,7 @@ writeCall.value = async (callSpec: CallSpec, metadata: FunctionMetadata) => {
             });
 
             if (result === "run") {
+                obj.onApplied();
                 // NOTE: I think awaiting here is fine, as the the prediction blockers don't wait based on the right call finishing, and I don't think anything really waits for this to finish. 
                 await baseAddCall(callSpec);
             } else {
@@ -533,6 +534,7 @@ export class QuerysubControllerBase {
         pathWatcher.unwatchPath({ callback: callerId, ...config });
     }
 
+    // NOTE: Calls are going to be temporary and random. Any user can use any call ID, so technically you could clobber other users' call IDs, or your our. There wouldn't really be any benefit. Nothing would really happen if you do that, so I don't believe these need to be kept secret. I think if you know someone else's call ID you might be able to read that data, but also it's securely random, so you're not going to be able to guess the call ID.
     public async addCall(call: CallSpec) {
         if (isBootstrapOnly()) throw new Error(`Cannot add calls to bootstrap only server`);
         if (Querysub.DEBUG_CALLS) {
@@ -661,19 +663,28 @@ export class QuerysubControllerBase {
     }
 
 
+    public async debugGetPathNodeIds(paths: string[]): Promise<Map<string, string | "missing">> {
+        await remoteWatcher.flushWatchers();
+        let result = new Map<string, string | "missing">();
+        for (let path of paths) {
+            let nodeId = remoteWatcher.getExistingWatchRemoteNodeId(path) ?? PathRouter.getReadyAuthority(path)?.nodeId ?? "missing";
+            result.set(path, nodeId);
+        }
+        return result;
+    }
+
     // NOTE: Maybe remove this? It's very useful for debugging though...
     public async debugGetSingleReadNode(path: string) {
         return PathRouter.getReadyAuthority(path)?.nodeId;
     }
 
-    public async debugGetPathAuthorities(nodeId: string) {
-        let authorities = await authorityLookup.getTopology();
-        return authorities.find(x => x.nodeId === nodeId)?.authoritySpec;
-    }
-
-    public async debugGetTopologyEntry(nodeId: string) {
+    public async debugGetNodeSpecs(): Promise<Map<string, { routeStart: number; routeEnd: number }>> {
         let topology = await authorityLookup.getTopology();
-        return topology.find(x => x.nodeId === nodeId);
+        let result = new Map<string, { routeStart: number; routeEnd: number }>();
+        for (let entry of topology) {
+            result.set(entry.nodeId, { routeStart: entry.authoritySpec.routeStart, routeEnd: entry.authoritySpec.routeEnd });
+        }
+        return result;
     }
 }
 
@@ -685,9 +696,9 @@ export const QuerysubController = SocketFunction.register(
         watch: { compress: true, },
         unwatch: { compress: true, },
         addCall: { compress: true, },
+        debugGetPathNodeIds: {},
+        debugGetNodeSpecs: {},
         debugGetSingleReadNode: {},
-        debugGetPathAuthorities: {},
-        debugGetTopologyEntry: {},
         getModulePath: {},
         getDevFunctionSpecFromCall: {},
     }),

package/src/4-querysub/predictionQueue.tsx

@@ -156,6 +156,9 @@ export async function runInPredictionQueue(config: {
 
     // Resolve all the values before us as well, before even our own promise, and then wait on that promise. That way, everything finishes in the same order it starts. 
     if (index >= 0) {
+        if (index > 1) {
+            console.log(`Flushing ${index} other calls due to ${callSpec.FunctionId}`);
+        }
         for (let i = 0; i <= index; i++) {
             commitQueue[i].resolveOrderedPromise.resolve();
         }

package/src/4-querysub/querysubPrediction.ts

@@ -8,7 +8,6 @@ import { getModuleFromConfig, setGitURLMapping } from "../3-path-functions/pathF
 import { logErrors } from "../errors";
 import { getPathFromStr, getPathStr1 } from "../path";
 import { Querysub, QuerysubController, QuerysubControllerBase, registerPredictionBlocker, querysubNodeId } from "./QuerysubController";
-import { Benchmark } from "../diagnostics/benchmark";
 import { parseArgs } from "../3-path-functions/PathFunctionHelpers";
 import { magenta, red } from "socket-function/src/formatting/logColors";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
@@ -21,6 +20,7 @@ import { isPublic } from "../config";
 import { clientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { cacheAsyncLimitedJSON } from "../functional/promiseCache";
 import { addEpsilons } from "../bits";
+import { delay } from "socket-function/src/batching";
 setFlag(require, "cbor-x", "allowclient", true);
 const cborEncoder = lazy(() => new cbor.Encoder({ structuredClone: true }));
 
@@ -90,13 +90,15 @@ const predictRunCommitLoop = (run: () => Promise<PredictResult | undefined>) =>
 
 // IMPORTANT! This has to be synchronous, and we need to synchronously get into the proxy watcher call. That way other calls after this know to wait for our proxy watcher to finish. Otherwise, it's very, very, very easy to write code, where you call a function, you expect it to write to a value, and then you run some other code, maybe which just uses a commit async, and tries to read from that value. But the value won't exist, because we won't even have started the prediction yet, and the proxy watcher can't possibly know to wait, because we haven't started the prediction. So... this has to be synchronous!
 export function predictCall(call: CallSpec, metadata: FunctionMetadata): {
+    onApplied: () => void;
     cancel: () => void;
     predictPromise: Promise<PredictResult | undefined>;
 } {
     let predictObj = predictCallBase({ call, metadata });
     let cancel = predictObj.cancel;
+    let onApplied = predictObj.onApplied;
     registerPredictionBlocker(call.CallId, predictObj.predictPromise);
-    return { cancel, predictPromise: predictObj.predictPromise };
+    return { cancel, onApplied, predictPromise: predictObj.predictPromise };
 }
 
 function getPredictTime(time: Time) {
@@ -115,12 +117,33 @@ function predictCallBase(config: {
     metadata: FunctionMetadata;
     overrides?: PathValue[];
 }): {
+    onApplied: () => void;
     cancel: () => void;
     predictPromise: Promise<PredictResult | undefined>;
 } {
     let call = config.call;
     let pathResultWrite = getCallResultPath(call);
-    Benchmark.onStartPredictCall(pathResultWrite);
+
+    let actualValueFinished = new PromiseObj();
+    function onActualFinished() {
+        if (actualValueFinished.resolveCalled) return;
+        let resultObj = authorityStorage.getValueAtTime(pathResultWrite, undefined);
+        let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
+        if (!result) return;
+        if (result.lastInternalLoopCount === -1) return;
+        actualValueFinished.resolve();
+        for (let callback of onPredictionFinishedCallbacks) {
+            callback({ callId: call.CallId, result, functionId: call.FunctionId });
+        }
+    }
+    function onApplied() {
+        clientWatcher.setWatches({
+            callback: onActualFinished,
+            paths: new Set([pathResultWrite]),
+            parentPaths: new Set(),
+        });
+    }
+
     let functionResult: FunctionResult = {
         // Special prediction values (we don't even really need to put anything here, but it
         //  might as well have the right format, in case a bug causes it to be used somewhere)
@@ -183,23 +206,6 @@ function predictCallBase(config: {
             readParentPaths: Set<string>;
         };
 
-        let actualValueFinished = new PromiseObj();
-        function onActualFinished() {
-            let resultObj = authorityStorage.getValueAtTime(pathResultWrite, undefined);
-            let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
-            if (!result) return;
-            if (result.lastInternalLoopCount === -1) return;
-            actualValueFinished.resolve();
-            for (let callback of onPredictionFinishedCallbacks) {
-                callback({ callId: call.CallId, result, functionId: call.FunctionId });
-            }
-        }
-        clientWatcher.setWatches({
-            callback: onActualFinished,
-            paths: new Set([pathResultWrite]),
-            parentPaths: new Set(),
-        });
-
         setTimeout(() => {
             clientWatcher.unwatch(onActualFinished);
         }, 30 * 1000);
@@ -360,6 +366,7 @@ function predictCallBase(config: {
     return {
         cancel: rejectPrediction,
         predictPromise,
+        onApplied,
     };
 }
 

package/src/5-diagnostics/nodeMetadata.ts

@@ -13,6 +13,7 @@ import { isNode } from "typesafecss";
 import { devDebugbreak } from "../config";
 import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, onTimeProfile, logNodeStats, logNodeStateStats, registerNodeMetadata } from "../-0-hooks/hooks";
 import { magenta } from "socket-function/src/formatting/logColors";
+import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
 
 
 let POLL_INTERVAL = timeInMinute * 5;
@@ -295,6 +296,16 @@ class NodeMetadataBase {
             };
         }));
     }
+
+    public async debugGetPathAuthorities(nodeId: string) {
+        let authorities = await authorityLookup.getTopology();
+        return authorities.find(x => x.nodeId === nodeId)?.authoritySpec;
+    }
+
+    public async debugGetTopologyEntry(nodeId: string) {
+        let topology = await authorityLookup.getTopology();
+        return topology.find(x => x.nodeId === nodeId);
+    }
 }
 export const NodeMetadataController = SocketFunction.register(
     "NodeMetadataController-8be51a16-27c2-449e-b044-dcef6c3efcaf",
@@ -303,5 +314,11 @@ export const NodeMetadataController = SocketFunction.register(
         getExtraMetadatas: {
             hooks: [requiresNetworkTrustHook],
         },
+        debugGetPathAuthorities: {
+            hooks: [requiresNetworkTrustHook],
+        },
+        debugGetTopologyEntry: {
+            hooks: [requiresNetworkTrustHook],
+        },
     }),
 );

package/src/diagnostics/NodeConnectionsPage.tsx

@@ -0,0 +1,167 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../4-dom/qreact";
+import { assertIsManagementUser } from "./managementPages";
+import { css } from "typesafecss";
+import { getSyncedController } from "../library-components/SyncedController";
+import { getAllNodeIds, getBrowserUrlNode } from "../-f-node-discovery/NodeDiscovery";
+import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
+import { debugNodeId } from "../-c-identity/IdentityController";
+import { fastHash } from "../misc/hash";
+import { NodeCapabilitiesController } from "../-g-core-values/NodeCapabilities";
+import { sort } from "socket-function/src/misc";
+
+
+
+function getColorForNodeId(friendlyNodeId: string): string {
+    let hash = fastHash(friendlyNodeId);
+    let hue = hash % 360;
+    return `hsl(${hue}, 70%, 60%)`;
+}
+
+export class NodeConnectionsPage extends qreact.Component {
+    render() {
+        let browserNode = getBrowserUrlNode();
+        let controller = nodeConnectionsController(browserNode);
+
+        let nodeIds = controller.getAllNodeIds();
+        if (!nodeIds) {
+            return <div class={css.pad2(10)}>Loading...</div>;
+        }
+
+        let connectableNodes: Array<{ nodeId: string; friendlyNodeId: string; entryPoint: string | undefined; connections: Array<{ nodeId: string; friendlyNodeId: string }> }> = [];
+        let nonConnectableNodes: string[] = [];
+
+        for (let nodeId of nodeIds) {
+            try {
+                let result = controller.getNodeConnections_forBrowser(nodeId);
+                if (result) {
+                    let friendlyNodeId = debugNodeId(nodeId);
+                    let entryPoint: string | undefined;
+                    try {
+                        entryPoint = controller.getEntryPoint_forBrowser(nodeId);
+                    } catch (e) {
+                        entryPoint = undefined;
+                    }
+                    connectableNodes.push({
+                        nodeId,
+                        friendlyNodeId,
+                        entryPoint,
+                        connections: result.connections,
+                    });
+                }
+            } catch (e) {
+                nonConnectableNodes.push(nodeId);
+            }
+        }
+
+        return (
+            <div class={css.pad2(10).vbox(20).fillWidth}>
+                <div class={css.vbox(10).fillWidth}>
+                    <h1>Connectable Nodes</h1>
+                    {connectableNodes.map(node => {
+                        let color = getColorForNodeId(node.friendlyNodeId);
+                        return (
+                            <div class={css.vbox(5).pad2(10).maxHeight(600).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
+                                <div class={css.vbox(3)}>
+                                    {node.entryPoint && (
+                                        <div class={css.fontSize(14).fontWeight("bold")}>
+                                            {node.entryPoint}
+                                        </div>
+                                    )}
+                                    <div class={css.hbox(5)}>
+                                        <span class={css.background(color).pad2(4, 2).fontWeight("bold")}>
+                                            {node.friendlyNodeId}
+                                        </span>
+                                        <span class={css.color("gray").fontSize(12)}>
+                                            ({node.nodeId})
+                                        </span>
+                                    </div>
+                                </div>
+                                <div class={css.vbox(3).paddingLeft(20)}>
+                                    {node.connections.length === 0 && (
+                                        <div class={css.color("gray")}>No connections</div>
+                                    )}
+                                    {node.connections.map(conn => {
+                                        let connColor = getColorForNodeId(conn.friendlyNodeId);
+                                        return (
+                                            <div class={css.hbox(5)}>
+                                                <span>→ Connected to:</span>
+                                                <span class={css.background(connColor).pad2(4, 2).fontWeight("bold")}>
+                                                    {conn.friendlyNodeId}
+                                                </span>
+                                                <span class={css.color("gray").fontSize(12)}>
+                                                    ({conn.nodeId})
+                                                </span>
+                                            </div>
+                                        );
+                                    })}
+                                </div>
+                            </div>
+                        );
+                    })}
+                </div>
+
+                <div class={css.vbox(10).fillWidth}>
+                    <h1>Non-Connectable Nodes</h1>
+                    <div class={css.vbox(5).pad2(10).maxHeight(600).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
+                        {nonConnectableNodes.map(nodeId => {
+                            let friendlyNodeId = debugNodeId(nodeId);
+                            return (
+                                <div class={css.hbox(5)}>
+                                    <span class={css.background("lightgray").pad2(4, 2).fontWeight("bold")}>
+                                        {friendlyNodeId}
+                                    </span>
+                                    <span class={css.color("gray").fontSize(12)}>
+                                        ({nodeId})
+                                    </span>
+                                    <span class={css.color("gray")}>- Can't connect</span>
+                                </div>
+                            );
+                        })}
+                    </div>
+                </div>
+            </div>
+        );
+    }
+}
+
+class NodeConnectionsControllerBase {
+    public async getNodeConnections() {
+        let factories = debugGetAllCallFactories();
+        let connections = factories.filter(x => x.isConnected).map(factory => ({
+            nodeId: factory.nodeId,
+            friendlyNodeId: debugNodeId(factory.nodeId),
+        }));
+        return { connections };
+    }
+
+    public async getNodeConnections_forBrowser(nodeId: string) {
+        let result = await NodeConnectionsController.nodes[nodeId].getNodeConnections();
+        sort(result.connections, x => x.friendlyNodeId);
+        return result;
+    }
+
+    public async getEntryPoint_forBrowser(nodeId: string) {
+        return await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+    }
+
+    public async getAllNodeIds() {
+        return await getAllNodeIds();
+    }
+}
+
+export const NodeConnectionsController = SocketFunction.register(
+    "NodeConnectionsController-8f3e2a1b-4c5d-4f2e-9a3b-7c8d1e2f3a4b",
+    new NodeConnectionsControllerBase(),
+    () => ({
+        getNodeConnections: {},
+        getNodeConnections_forBrowser: {},
+        getEntryPoint_forBrowser: {},
+        getAllNodeIds: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    })
+);
+
+export const nodeConnectionsController = getSyncedController(NodeConnectionsController);

package/src/diagnostics/NodeViewer.tsx

@@ -2,7 +2,7 @@ import { qreact } from "../../src/4-dom/qreact";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { css } from "typesafecss";
 import { getAllNodeIds, getBrowserUrlNode, syncNodesNow } from "../../src/-f-node-discovery/NodeDiscovery";
-import { errorToUndefined, logErrors, timeoutToError } from "../../src/errors";
+import { errorToUndefined, errorToUndefinedSilent, logErrors, timeoutToError } from "../../src/errors";
 import { Querysub, QuerysubController } from "../../src/4-querysub/QuerysubController";
 import { NodeCapabilitiesController, getControllerNodeIdList } from "../../src/-g-core-values/NodeCapabilities";
 import { lazy } from "socket-function/src/caching";
@@ -37,7 +37,7 @@ type NodeData = {
     ip?: string;
     devToolsURL?: string;
 
-    live_isReadReady?: boolean;
+    live_isAlive?: boolean;
     live_authorityPaths?: AuthoritySpec;
     live_exposedControllers?: string[];
     live_entryPoint?: string;
@@ -79,7 +79,7 @@ export class NodeViewer extends qreact.Component {
                     let data: NodeData = { nodeId };
                     try {
                         data.table = await controller.getMiscInfo(nodeId);
-                        data.live_isReadReady = await controller.live_isReadReady(nodeId);
+                        data.live_isAlive = await controller.live_isAlive(nodeId);
                         data.live_exposedControllers = await controller.getExposedControllers(nodeId);
                         data.live_entryPoint = await controller.live_getEntryPoint(nodeId);
                         data.live_trueTimeOffset = await controller.live_getTrueTimeOffset(nodeId);
@@ -147,7 +147,7 @@ export class NodeViewer extends qreact.Component {
         let nodeDatas = Object.values(this.state.nodes);
         let deadCount = 0;
         if (!showNotReadyNodes.value) {
-            let ready = nodeDatas.filter(x => x.live_isReadReady);
+            let ready = nodeDatas.filter(x => x.live_isAlive);
             deadCount = nodeDatas.length - ready.length;
             nodeDatas = ready;
         }
@@ -175,7 +175,7 @@ export class NodeViewer extends qreact.Component {
         tables["PathValueServer"] = [];
         tables["Querysub"] = [];
         for (let datum of nodeDatas) {
-            if (datum.live_authorityPaths) {
+            if (datum.live_authorityPaths?.prefixes.length) {
                 tables["PathValueServer"].push(datum);
             } else if (datum.live_exposedControllers?.includes("QuerysubController-6db5ef05-7563-4473-a440-2f64f03fe6ef")) {
                 tables["Querysub"].push(datum);
@@ -492,12 +492,11 @@ class NodeViewerControllerBase {
         return await getControllerNodeIdList(controller);
     }
 
-    public async live_isReadReady(nodeId: string) {
-        let topo = await QuerysubController.nodes[nodeId].debugGetTopologyEntry(nodeId);
-        return !!topo?.isReady;
+    public async live_isAlive(nodeId: string) {
+        return !!await errorToUndefinedSilent(NodeCapabilitiesController.nodes[nodeId].getEntryPoint());
     }
     public async live_getAuthorityPaths(nodeId: string) {
-        let topo = await QuerysubController.nodes[nodeId].debugGetTopologyEntry(nodeId);
+        let topo = await NodeMetadataController.nodes[nodeId].debugGetTopologyEntry(nodeId);
         return topo?.authoritySpec;
     }
     public async live_getEntryPoint(nodeId: string) {
@@ -524,7 +523,7 @@ class NodeViewerControllerBase {
         }
         let promises = [
             wrapAddTableValue("paths|paths", {}, async () => {
-                let live_authorityPaths = (await QuerysubController.nodes[nodeId].debugGetPathAuthorities(nodeId));
+                let live_authorityPaths = (await NodeMetadataController.nodes[nodeId].debugGetPathAuthorities(nodeId));
                 return JSON.stringify(live_authorityPaths);
             }),
             wrapAddTableValue("paths|functions", {}, async () => {
@@ -549,15 +548,12 @@ class NodeViewerControllerBase {
                 return nodeId.split(".").at(-3);
             }),
             wrapAddTableValue("miscAudits", { formatter: "varray:error" }, async () => {
-                let liveTopo = await QuerysubController.nodes[nodeId].debugGetTopologyEntry(nodeId);
+                let liveTopo = await NodeMetadataController.nodes[nodeId].debugGetTopologyEntry(nodeId);
                 let live_authorityPaths = liveTopo?.authoritySpec;
                 let obj = await authorityLookup.getTopology();
                 let cached_authority = await obj.find(x => x.nodeId === nodeId);
-                let live_isReadReady = liveTopo?.isReady;
                 return [
-                    live_isReadReady && !cached_authority && `Authority is missing in cache`,
                     JSON.stringify(live_authorityPaths) !== JSON.stringify(cached_authority) && `Paths are out of sync. Cache has ${JSON.stringify(cached_authority)} live has ${JSON.stringify(live_authorityPaths)}`,
-                    live_isReadReady !== cached_authority?.isReady && `isReadReady is out of sync. Cache has ${cached_authority?.isReady} live has ${live_isReadReady}`,
                 ].filter(x => x);
             }),
             wrapAddTableValue("capabilities|capabilities", {}, async () => {
@@ -596,7 +592,7 @@ export const NodeViewerController = SocketFunction.register(
         getAllNodeIds: {},
         getExposedControllers: {},
         getControllerNodeIdList: {},
-        live_isReadReady: {},
+        live_isAlive: {},
         live_getAuthorityPaths: {},
         live_getEntryPoint: {},
         live_getTrueTimeOffset: {},