querysub 0.474.0 → 0.476.0

package/.claude/settings.local.json

@@ -24,7 +24,8 @@
       "mcp__node-debugger__listBreakpoints",
       "mcp__node-debugger__removeBreakpoint",
       "mcp__hottest__runTest",
-      "Bash(yarn test *)"
+      "Bash(yarn test *)",
+      "Bash(yarn ssh-a-claude *)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.474.0",
+  "version": "0.476.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -23,7 +23,8 @@
     "mcp": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts",
     "mc": "yarn typenode ./src/diagnostics/logs/IndexedLogs/MCPIndexedLogsEntry.ts --cwd D:/repos/qs-cyoa/",
     "mcp2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts",
-    "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/"
+    "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/",
+    "ssh-a-claude": "ssh root@a.querysubtest.com"
   },
   "bin": {
     "deploy": "./bin/deploy.js",
@@ -66,7 +67,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "socket-function": "^1.1.36",
+    "socket-function": "^1.1.40",
     "terser": "^5.31.0",
     "typesafecss": "^0.29.0",
     "yaml": "^2.5.0",
@@ -81,6 +82,7 @@
     "typedev": "^0.3.0"
   },
   "resolutions": {
-    "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6"
+    "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
+    "socket-function": "^1.1.40"
   }
 }

package/src/-c-identity/IdentityController.ts

@@ -10,7 +10,7 @@ import { CallerContext } from "socket-function/SocketFunctionTypes";
 import { cache, cacheWeak, lazy } from "socket-function/src/caching";
 import { getClientNodeId, getNodeId, getNodeIdDomain, getNodeIdIP, getNodeIdLocation, isClientNodeId } from "socket-function/src/nodeCache";
 import { decodeNodeId, getCommonName, getIdentityCA, getMachineId, getOwnMachineId, getPublicIdentifier, getThreadKeyCert, parseCert, sign, validateCertificate, verify } from "../-a-auth/certs";
-import { getShortNumber } from "../bits";
+import { getShortNumber } from "socket-function/src/bits";
 import { measureBlock, measureFnc, measureWrap } from "socket-function/src/profiling/measure";
 import { timeoutToError } from "../errors";
 import { delay } from "socket-function/src/batching";

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

@@ -7,7 +7,7 @@ import { compare, recursiveFreeze } from "socket-function/src/misc";
 import { MaybePromise } from "socket-function/src/types";
 import { StringSerialize } from "./stringSerializer";
 import { Zip } from "../zip";
-import { asBuffer, asInt32, asUint32 } from "../buffers";
+import { asBuffer, asInt32, asUint32 } from "socket-function/src/buffers";
 import { setFlag } from "socket-function/require/compileFlags";
 
 import cbor from "cbor-x";

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

@@ -1,6 +1,6 @@
 import debugbreak from "debugbreak";
 import { measureFnc, measureWrap } from "socket-function/src/profiling/measure";
-import { asFloat64 } from "../buffers";
+import { asFloat64 } from "socket-function/src/buffers";
 
 export class StringSerialize {
 

package/src/0-path-value-core/PathRouter.ts

@@ -11,7 +11,7 @@ import { getRoutingOverride, hasPrefixHash } from "./PathRouterRouteOverride";
 import { sha256 } from "js-sha256";
 import { rangesOverlap, removeRange } from "../rangeMath";
 import { decodeParentFilter } from "./hackedPackedPathParentFiltering";
-import { getBufferInt } from "../bits";
+import { getBufferInt } from "socket-function/src/bits";
 
 import { LOCAL_DOMAIN, LOCAL_DOMAIN_PATH } from "./PathRouterConstants";
 export { LOCAL_DOMAIN, LOCAL_DOMAIN_PATH };

package/src/0-path-value-core/pathValueCore.ts

@@ -1,6 +1,6 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { cacheLimited, lazy } from "socket-function/src/caching";
-import { addEpsilons, minusEpsilon } from "../bits";
+import { addEpsilons, getTimeUnique, minusEpsilon } from "socket-function/src/bits";
 import { logErrors } from "../errors";
 import { appendToPathStr, getParentPathStr, getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPackedPathSuffix, hack_stripPackedPath } from "../path";
 import { measureFnc, measureWrap } from "socket-function/src/profiling/measure";
@@ -352,15 +352,7 @@ export function compareTime(lhs: Time, rhs: Time) {
 export function getCreatorId() {
     return IdentityController_getOwnPubKeyShort();
 }
-let prevTime = 0;
-export function getTimeUnique() {
-    let time = Date.now();
-    if (time <= prevTime) {
-        time = addEpsilons(prevTime, 1);
-    }
-    prevTime = time;
-    return time;
-}
+
 
 export let debugRejections = false;
 export function enableDebugRejections() {

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -7,13 +7,13 @@ import { cache, cacheLimited, lazy } from "socket-function/src/caching";
 import { delay, runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { errorify, logErrors } from "../errors";
 import { appendToPathStr, getLastPathPart, getParentPathStr, getPathDepth, getPathFromStr, getPathIndex, getPathIndexAssert, getPathPrefix, getPathStr1, getPathStr2, getPathSuffix, slicePathStrToDepth } from "../path";
-import { addEpsilons } from "../bits";
+import { addEpsilons, getTimeUnique } from "socket-function/src/bits";
 import { getThreadKeyCert } from "../-a-auth/certs";
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { registerResource } from "../diagnostics/trackResources";
 import { ClientWatcher, WatchSpecData, clientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { createPathValueProxy, getPathFromProxy, getProxyPath, getProxyPathAndWatch, isValueProxy, isValueProxy2 } from "./pathValueProxy";
-import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId, getTimeUnique, debugTime } from "../0-path-value-core/pathValueCore";
+import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId, debugTime } from "../0-path-value-core/pathValueCore";
 import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
 import debugbreak from "debugbreak";
 import { pathValueCommitter } from "../0-path-value-core/PathValueController";
@@ -1957,6 +1957,10 @@ export class PathValueProxyWatcher {
     public runOnce<Result = void>(
         options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
     ): Result {
+        // TODO: This is a recent change. We maybe should apply the user pass and options. However, we definitely don't want to call create watcher as that will apply our additional options, making it temporary, where this might actually be run inside of a non-temporary watcher like a render function. Which finally will break on commit finish because it'll think it's in a temporary function and subscribe to the wrong callback. 
+        if (this.inWatcher()) {
+            return options.watchFunction();
+        }
         let result: { result: Result } | { error: string } | undefined;
         let watcher = this.createWatcher({
             ...options,

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

@@ -1,7 +1,7 @@
 import { getOwnMachineId } from "../-a-auth/certs";
 import { atomicObjectWrite, proxyWatcher, specialObjectWriteSymbol } from "../2-proxy/PathValueProxyWatcher";
 import { pathValueCommitter } from "../0-path-value-core/PathValueController";
-import { getNextTime, getTimeUnique } from "../0-path-value-core/pathValueCore";
+import { getNextTime } from "../0-path-value-core/pathValueCore";
 import { FunctionSpec, functionSchema, CallSpec, commitCall } from "./PathFunctionRunner";
 import { logErrors } from "../errors";
 import { FunctionMetadata, getCallIdOverride } from "./syncSchema";
@@ -21,6 +21,7 @@ import { PathRouter } from "../0-path-value-core/PathRouter";
 import { getPathFromProxy } from "../2-proxy/pathValueProxy";
 import { getDomain, isPublic } from "../config";
 import { getFncFilter, isServer } from "../config2";
+import { getTimeUnique } from "socket-function/src/bits";
 
 // NOTE: We could deploy single functions, but... we will almost always be updating all functions at
 //      once, because keeping everything on the same git hash reduces a lot of potential bugs.

package/src/4-deploy/git.ts

@@ -126,18 +126,52 @@ export const setGitRef = measureWrap(async function setGitRef(config: {
     gitRef: string;
 }) {
     await fs.promises.mkdir(config.gitFolder, { recursive: true });
-    let hostKey = await runPromise(`ssh-keyscan -t rsa bitbucket.org`);
-    hostKey = hostKey.split("\n").filter(x => !x.startsWith("#")).join("\n");
-    let knownHostsPath = os.homedir() + "/.ssh/known_hosts";
-    if (!fs.existsSync(knownHostsPath) || !fs.readFileSync(knownHostsPath).toString().includes(hostKey)) {
-        fs.appendFileSync(knownHostsPath, "\n" + hostKey + "\n");
+    // ssh-keyscan is a network call; a transient failure here must not abort the sync. The host key is normally already in known_hosts from machine setup, and callers only escalate to clobbering the checkout on *repo* failures — not on a momentary inability to refresh a host key.
+    try {
+        let hostKey = await runPromise(`ssh-keyscan -t rsa bitbucket.org`);
+        hostKey = hostKey.split("\n").filter(x => !x.startsWith("#")).join("\n");
+        let knownHostsPath = os.homedir() + "/.ssh/known_hosts";
+        if (hostKey && (!fs.existsSync(knownHostsPath) || !fs.readFileSync(knownHostsPath).toString().includes(hostKey))) {
+            fs.appendFileSync(knownHostsPath, "\n" + hostKey + "\n");
+        }
+    } catch (e: any) {
+        console.warn(`ssh-keyscan for bitbucket.org failed, continuing: ${e.stack ?? e}`);
     }
 
     await runPromise(`git remote update`, { cwd: config.gitFolder });
     await runPromise(`git add --all`, { cwd: config.gitFolder });
-    await runPromise(`git stash`, { cwd: config.gitFolder });
+    // nothrow: on a freshly re-initialized repo (rebuildGitFolder) there is no initial commit yet, so `git stash` errors. That's harmless — the `git reset --hard` below is what actually forces the working tree to the target ref.
+    await runPromise(`git stash`, { cwd: config.gitFolder, nothrow: true });
     await runPromise(`git fetch --all`, { cwd: config.gitFolder });
     await runPromise(`git reset --hard ${config.gitRef}`, { cwd: config.gitFolder });
     // Allows us to remove deleted objects from storage, ex, if we accidentally commit a 1GB, this deletes it, so we don't have to fix each server individually. Also I think the repo breaks if we go too long without pruning it?
     await runPromise(`git prune`, { cwd: config.gitFolder });
+});
+
+/** Recovers a broken repo WITHOUT disturbing the working-tree files. We delete only .git, re-init, re-add the remote, then let setGitRef's `git reset --hard` reconcile the tracked files to the ref. Untracked / gitignored files (notably node_modules, which is expensive to reinstall and may be open in a running service) are left exactly as they are. When the directory is empty this produces the same result as a fresh clone. */
+export const rebuildGitFolder = measureWrap(async function rebuildGitFolder(config: {
+    gitFolder: string;
+    repoUrl: string;
+    gitRef: string;
+}) {
+    await fs.promises.mkdir(config.gitFolder, { recursive: true });
+    await fs.promises.rm(config.gitFolder + ".git", { recursive: true, force: true });
+    await runPromise(`git init`, { cwd: config.gitFolder });
+    await runPromise(`git remote add origin ${config.repoUrl}`, { cwd: config.gitFolder });
+    await setGitRef({ gitFolder: config.gitFolder, gitRef: config.gitRef });
+});
+
+/** Last-resort recovery for a working tree git can't reconcile (rebuildGitFolder failed). Clones fresh into a sibling temp directory and swaps it in only after the clone and ref-set succeed, so a failed/interrupted clone can never leave the live folder empty — the failure mode that previously stranded running services with a deleted node_modules. This necessarily discards node_modules; the caller reinstalls it. */
+export const nuclearReclone = measureWrap(async function nuclearReclone(config: {
+    gitFolder: string;
+    repoUrl: string;
+    gitRef: string;
+}) {
+    let target = config.gitFolder.replace(/[\/\\]+$/, "");
+    let tempDir = target + ".reclone-" + Date.now();
+    await fs.promises.rm(tempDir, { recursive: true, force: true });
+    await runPromise(`git clone ${config.repoUrl} ${tempDir}`);
+    await setGitRef({ gitFolder: tempDir + "/", gitRef: config.gitRef });
+    await fs.promises.rm(target, { recursive: true, force: true });
+    await fs.promises.rename(tempDir, target);
 });

package/src/4-querysub/Querysub.ts

@@ -1349,7 +1349,7 @@ import "../diagnostics/watchdog";
 import "../diagnostics/trackResources";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { getCountPerPaint } from "../functional/onNextPaint";
-import { addEpsilons } from "../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { blue, green, magenta } from "socket-function/src/formatting/logColors";
 import { MachineController } from "../deployManager/machineController";
 import { getRecords, setRecord } from "../-b-authorities/dnsAuthority";

package/src/4-querysub/querysubPrediction.ts

@@ -20,7 +20,7 @@ import { PromiseObj, isNode } from "socket-function/src/misc";
 import { isPublic } from "../config";
 import { clientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { cacheAsyncLimitedJSON } from "../functional/promiseCache";
-import { addEpsilons } from "../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { delay } from "socket-function/src/batching";
 setFlag(require, "cbor-x", "allowclient", true);
 const cborEncoder = lazy(() => new cbor.Encoder({ structuredClone: true }));

package/src/deployManager/machineApplyMainCode.ts

@@ -13,12 +13,12 @@ import { formatTime } from "socket-function/src/formatting/format";
 import { sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { isDefined } from "../misc";
 import { logLoadTime } from "../logModuleLoadTimes";
-import { delay, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { delay, retryFunctional, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import os from "os";
 import fs from "fs";
 import { spawn, ChildProcess } from "child_process";
 import { lazy } from "socket-function/src/caching";
-import { getGitRefLive, getGitURLLive, setGitRef } from "../4-deploy/git";
+import { getGitRefLive, getGitURLLive, setGitRef, rebuildGitFolder, nuclearReclone } from "../4-deploy/git";
 import { blue, green, magenta, red } from "socket-function/src/formatting/logColors";
 import { shutdown } from "../diagnostics/periodic";
 import { onServiceConfigChange, triggerRollingUpdate } from "./machineController";
@@ -607,24 +607,53 @@ const killScreen = measureWrap(async function killScreen(config: {
     await runPromise(`${prefix}tmux kill-session -t ${config.screenName}`);
     await removeOldNodeId(config.screenName);
 });
+// When a present repo fails to sync, retry a few times with backoff before deciding it is actually broken — most failures are transient network blips (ssh-keyscan / fetch), and reacting to those by clobbering the checkout is what stranded running services (they kept running but crashed on the next lazy `require("ws")` once node_modules was gone).
+const GIT_SYNC_MAX_RETRIES = 4;
+const GIT_SYNC_RETRY_MIN_DELAY = timeInSecond * 2;
+const GIT_SYNC_RETRY_MAX_DELAY = timeInSecond * 30;
+
 const ensureGitSynced = measureWrap(async function ensureGitSynced(config: {
-    // Ensures existingFolder is the repo, as in, cwd to it, and git clone ., if needed. Reset the hash, in whatever way we need to, to force it to gitRef (git add --all and stash, etc, etc).
-    //  - Maybe ask the AI the best way to forcefully switch a git repo.
+    // Forces the checkout at gitFolder to gitRef. Escalates through increasingly destructive recoveries, but only ever destroys the working tree as an absolute last resort — a network blip must never wipe node_modules out from under a running service.
     gitFolder: string;
     repoUrl: string;
     gitRef: string;
 }) {
-    try {
-        if (!await fsExistsAsync(config.gitFolder + ".git")) {
-            await runPromise(`git clone ${config.repoUrl} ${config.gitFolder}`);
+    let hasGit = await fsExistsAsync(config.gitFolder + ".git");
+
+    // Repo present: sync to the ref, retrying transient failures with backoff. We do NOT clobber the checkout just because a network call blipped.
+    if (hasGit) {
+        try {
+            await retryFunctional(() => setGitRef(config), {
+                maxRetries: GIT_SYNC_MAX_RETRIES,
+                minDelay: GIT_SYNC_RETRY_MIN_DELAY,
+                maxDelay: GIT_SYNC_RETRY_MAX_DELAY,
+            })();
+            return;
+        } catch (e: any) {
+            console.error(`Failed to sync git ref after ${GIT_SYNC_MAX_RETRIES} retries; rebuilding .git in place next (working tree, incl. node_modules, is preserved).`, {
+                gitFolder: config.gitFolder,
+                repoUrl: config.repoUrl,
+                gitRef: config.gitRef,
+                error: e?.stack ?? String(e),
+            });
         }
-        await setGitRef(config);
+    }
+
+    // Repo missing, or present-but-unsyncable: rebuild just the .git metadata and let `git reset --hard` reconcile the tracked files. The working-tree files (node_modules) are left untouched. Equivalent to a clone when the folder is empty.
+    try {
+        await rebuildGitFolder(config);
+        return;
     } catch (e: any) {
-        console.warn(`Failed to set git ref, trying to delete and clone again (${config.gitFolder}): ${e.stack}`);
-        await fs.promises.rm(config.gitFolder, { recursive: true });
-        await runPromise(`git clone ${config.repoUrl} ${config.gitFolder}`);
-        await setGitRef(config);
+        console.error(`Rebuilding .git in place failed; falling back to a full delete + clone (this wipes node_modules, which the caller reinstalls).`, {
+            gitFolder: config.gitFolder,
+            repoUrl: config.repoUrl,
+            gitRef: config.gitRef,
+            error: e?.stack ?? String(e),
+        });
     }
+
+    // Nuclear: the working tree itself is unusable. Clone fresh (into a temp dir, swapped in only on success).
+    await nuclearReclone(config);
 });
 
 
@@ -710,8 +739,10 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                         gitRef: config.parameters.gitRef,
                     });
                     let afterGitRef = await getGitRefLive(gitFolder);
-                    if (afterGitRef !== prevGitRef) {
-                        console.log(green(`Yarn installing because git ref changed from ${prevGitRef} to ${afterGitRef} for ${magenta(screenName)}`));
+                    // Reinstall when the ref changed OR node_modules is missing. The latter is the real fix for the "Cannot find module 'ws'" crash: a recovery re-clone can land on the same commit, so a ref-only check would skip the install and leave the service with no node_modules. Restoring node_modules also self-heals an already-running process, since a failed `require` is never cached and the next reconnect re-resolves it.
+                    let nodeModulesMissing = !await fsExistsAsync(gitFolder + "node_modules");
+                    if (afterGitRef !== prevGitRef || nodeModulesMissing) {
+                        console.log(green(`Yarn installing for ${magenta(screenName)} (ref ${prevGitRef} -> ${afterGitRef}, nodeModulesMissing=${nodeModulesMissing})`));
                         await runPromise(`yarn install`, { cwd: gitFolder });
                     }
                 }

package/src/diagnostics/logs/diskLogger.ts

@@ -4,7 +4,7 @@ import { canHaveChildren } from "socket-function/src/types";
 import { lazy } from "socket-function/src/caching";
 import { timeInMinute } from "socket-function/src/misc";
 import { formatTime } from "socket-function/src/formatting/format";
-import { addEpsilons } from "../../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { getPathStr2 } from "../../path";
 import { isPublic } from "../../config";
 import type { IndexedLogs } from "./IndexedLogs/IndexedLogs";

package/src/diagnostics/misc-pages/ArchiveViewer.tsx

@@ -17,7 +17,7 @@ import { isEmpty } from "../../misc";
 import { PathValue, epochTime } from "../../0-path-value-core/pathValueCore";
 import { pathValueSerializer } from "../../-h-path-value-serialize/PathValueSerializer";
 import { InputLabel } from "../../library-components/InputLabel";
-import { addEpsilons } from "../../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { ArchiveViewerTable } from "./ArchiveViewerTable";
 import { liveWatchPaths, skipStringsURL, skipValuesURL, startTime, endTime, addFileCount, archiveFileValue, filtersURL, viewMode, archiveViewerDiskCache } from "./archiveViewerShared";

package/src/diagnostics/misc-pages/ArchiveViewerTable.tsx

@@ -2,7 +2,7 @@ import preact from "preact"; import { qreact } from "../../4-dom/qreact";
 import { pathValueSerializer } from "../../-h-path-value-serialize/PathValueSerializer";
 import { PathValue } from "../../0-path-value-core/pathValueCore";
 import { atomic, atomicObjectWrite } from "../../2-proxy/PathValueProxyWatcher";
-import { getLowUint32 } from "../../bits";
+import { getLowUint32 } from "socket-function/src/bits";
 import { Button } from "../../library-components/Button";
 import { InputLabel } from "../../library-components/InputLabel";
 import { getPathFromStr, getPathStr } from "../../path";

package/src/diagnostics/misc-pages/ComponentSyncStats.tsx

@@ -5,7 +5,7 @@ import { css } from "../../4-dom/css";
 import { TimeRangeView } from "./TimeRangeView";
 import { URLParam } from "../../library-components/URLParam";
 import { InputLabelURL } from "../../library-components/InputLabel";
-import { addEpsilons } from "../../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { formatNumber, formatPercent, formatTime } from "socket-function/src/formatting/format";
 import { nextId, sort } from "socket-function/src/misc";
 import { ATag } from "../../library-components/ATag";

package/src/diagnostics/misc-pages/LocalWatchViewer.tsx

@@ -17,7 +17,7 @@ import { throttleRerender } from "../../functional/throttleRerender";
 import { InputLabel, InputLabelURL } from "../../library-components/InputLabel";
 import { formatTime } from "socket-function/src/formatting/format";
 import { TimeRange, TimeRangeView, getUniqueTimeByPath, normalizeTimeRanges } from "./TimeRangeView";
-import { addEpsilons } from "../../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { LOCAL_DOMAIN_PATH } from "../../0-path-value-core/PathRouter";
 
 export const watchValueType = new URLParam("valueType", "watch" as "watch" | "component");

package/src/library-components/Histogram.tsx

@@ -7,7 +7,7 @@ import { performDrag2 } from "../library-components/drag";
 import { atomic, atomicObjectSymbol, atomicObjectWrite } from "../2-proxy/PathValueProxyWatcher";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
 import { authorityStorage } from "../0-path-value-core/pathValueCore";
-import { addEpsilons } from "../bits";
+import { addEpsilons } from "socket-function/src/bits";
 import { Querysub } from "../4-querysub/Querysub";
 import { MeasuredDiv } from "../library-components/MeasuredDiv";
 

package/src/library-components/SyncedController.ts

@@ -1,4 +1,4 @@
-import { atomic, atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites, isTransparentValue, proxyWatcher, specialObjectWriteValue } from "../../src/2-proxy/PathValueProxyWatcher";
+import { atomic, atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites, doProxyOptions, isTransparentValue, proxyWatcher, specialObjectWriteValue } from "../../src/2-proxy/PathValueProxyWatcher";
 import { Querysub } from "../../src/4-querysub/Querysub";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { FullCallType, SocketRegistered } from "socket-function/SocketFunctionTypes";
@@ -91,6 +91,25 @@ const writeWatchers = new Map<string, {
     fncName: string;
 }[]>();
 
+export function asyncCache<T>(fnc: () => Promise<T>): (...args: any[]) => T | undefined {
+    return getSyncedController({
+        nodes: {
+            "": {
+                fnc,
+            },
+        },
+    })("").fnc;
+}
+export function asyncCacheObj<T>(fncs: T): {
+    [key in keyof T]: T[key] extends (...args: any[]) => Promise<infer Return> ? (...args: any[]) => Return | undefined : never;
+} {
+    return getSyncedController({
+        nodes: {
+            "": fncs as any,
+        },
+    })("") as any;
+}
+
 export function getSyncedController<T extends {
     nodes: {
         [key: string]: {
@@ -274,12 +293,15 @@ export function getSyncedController<T extends {
                         });
                         // We have to wait until we actually commit before making the call. Otherwise, if this commit is rejected because we need to do synchronized values, we'll call the function twice.
                         let fnc = controller.nodes[nodeId][fncName] as any;
+                        console.log(`Triggering call ${fncName} with args ${JSON.stringify(args)}`);
                         Querysub.onCommitFinished(() => {
-                            if (Querysub.isAllSynced()) {
-                                void Promise.resolve().then(() => {
-                                    doPromiseCall();
-                                });
-                            }
+                            console.log(`Commit finished for call ${fncName} with args ${JSON.stringify(args)}`);
+                            // Doesn't on commit finished also implicitly mean we're all synced? Pretty sure that isAll synced is making things break. 
+                            //if (Querysub.isAllSynced()) {
+                            void Promise.resolve().then(() => {
+                                doPromiseCall();
+                            });
+                            //}
                         });
                         function doPromiseCall() {
                             let promise = fnc(...args) as Promise<unknown>;
@@ -347,7 +369,10 @@ export function getSyncedController<T extends {
                                 }
                             }
                         }
+                        // Force it to commit, so even if we aren't synced, it runs.
+                        //doProxyOptions({ commitAllRuns: true }, () => {
                         call(...args);
+                        //});
                         // Assign to itself, to preset the type assumptions typescript makes (otherwise we get an error below)
                         obj = obj as any;
                         if (config?.cachePromiseCalls) {

package/src/storage/diskCache.ts

@@ -1,4 +1,4 @@
-import { asBuffer } from "../buffers";
+import { asBuffer } from "socket-function/src/buffers";
 import { assert, assertValue, logErrors } from "../errors";
 import { batchFunction } from "socket-function/src/batching";
 import { lazy } from "socket-function/src/caching";

package/src/zipThreaded.ts

@@ -4,7 +4,7 @@ import { Worker } from "worker_threads";
 import { isNode } from "typesafecss";
 import { PromiseObj } from "./promise";
 import debugbreak from "debugbreak";
-import { asBuffer } from "./buffers";
+import { asBuffer } from "socket-function/src/buffers";
 
 
 let getWorkerLimit = lazy(() => {

package/src/bits.ts

@@ -1,105 +0,0 @@
-
-/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
- *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
- */
-export function minusEpsilon(value: number) {
-    let high = getHighUint32(value);
-    let low = getLowUint32(value);
-
-    if (low === 0) {
-        low = 2 ** 32 - 1;
-        high--;
-    } else {
-        low--;
-    }
-
-    return setLowHighUint32(low, high);
-}
-const maxUint32 = 2 ** 32 - 1;
-export function addEpsilons(value: number, count: number) {
-    let high = getHighUint32(value);
-    let low = getLowUint32(value);
-
-    low += count;
-    if (low < 0) {
-        low += maxUint32;
-        high++;
-    } else if (low > maxUint32) {
-        low -= maxUint32;
-        high--;
-    }
-
-    return setLowHighUint32(low, high);
-}
-
-let conversionBuffer = new Float64Array(1);
-let conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);
-let conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);
-export function getHighUint32(num: number): number {
-    conversionBuffer[0] = num;
-    return conversionUint32Buffer[1];
-}
-export function getLowUint32(num: number): number {
-    conversionBuffer[0] = num;
-    return conversionUint32Buffer[0];
-}
-
-/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
- *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
- */
-export function setLowHighUint32(low: number, high: number): number {
-    conversionUint32Buffer[0] = low;
-    conversionUint32Buffer[1] = high;
-    return conversionBuffer[0];
-}
-
-/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
-    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter. 
-*/
-export function setLowHighUint32Safe(low: number, high: number): number {
-    conversionUint32Buffer[0] = low;
-    // Prevent NaN by not setting all the exponent bits to 1
-    conversionUint32Buffer[1] = high & 0xBFFFFFFF;
-    return conversionBuffer[0];
-}
-
-// NOTE: Not reversible, see setLowHighUint32Safe
-export function xor64BitsSafe(a: number, b: number): number {
-    let high = getHighUint32(a);
-    let low = getLowUint32(a);
-    let high2 = getHighUint32(b);
-    let low2 = getLowUint32(b);
-    return setLowHighUint32Safe(low ^ low2, high ^ high2);
-}
-
-// Gets bits that can be stored in a number. Specifically, the first 62 bits,
-//  as 64 bits will not compare correctly when treated as a double.
-export function getShortNumber(buffer: Buffer): number {
-    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;
-    let low = buffer.readUInt32BE(4);
-    return setLowHighUint32(low, high);
-}
-/* Returns a number between 0 and 2**48 */
-export function getBufferInt(buffer: Buffer): number {
-    let num = 0;
-    for (let i = 0; i < Math.min(buffer.length, 6); i++) {
-        num = num * 256 + buffer[i];
-    }
-    return num;
-}
-const intMax = 2 ** 48;
-/** Returns a number between 0 (inclusive) and 1 (exclusive) */
-export function getBufferFraction(buffer: Buffer): number {
-    let int = getBufferInt(buffer);
-    return int / intMax;
-}
-
-/*
-export function numberToBase64(num: number): string {
-    conversionBuffer[0] = num;
-    return Buffer.from(conversionBuffer.buffer).toString("base64");
-}
-export function numberFromBase64(base64: string) {
-    return new Float64Array(Buffer.from(base64, "base64"))[0];
-}
-*/

package/src/buffers.ts

@@ -1,69 +0,0 @@
-import { canHaveChildren } from "socket-function/src/types";
-
-export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
-export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
-
-export function cloneBuffer(data: Buffer): Buffer {
-    let newBuffer = Buffer.alloc(data.length);
-    data.copy(newBuffer);
-    return newBuffer;
-}
-
-
-export function asBuffer(data: BufferType): Buffer {
-    if (!data) return data;
-    if (data instanceof Buffer) return data;
-    if (!canHaveChildren(data)) return data as any;
-    if (!("buffer" in data) || !("byteOffset" in data) || !("byteLength" in data)) {
-        return Buffer.from(data);
-    }
-    let result = Buffer.from((data as any).buffer, (data as any).byteOffset, (data as any).byteLength);
-    return result;
-}
-export function asFloat64(data: Buffer): Float64Array {
-    if (data.length % 8 !== 0) {
-        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 8 !== 0) {
-        throw new Error(`Data is not 8 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
-}
-export function asFloat32(data: Buffer): Float32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Float32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-export function asUint32(data: Buffer): Uint32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Uint32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-export function asInt32(data: Buffer): Int32Array {
-    if (data.length % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 4 !== 0) {
-        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
-    }
-    return new Int32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
-}
-
-
-export function asFloat64MaybeCopy(data: Buffer) {
-    if (data.length % 8 !== 0) {
-        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
-    }
-    if (data.byteOffset % 8 !== 0) {
-        return asFloat64(cloneBuffer(data));
-    }
-    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
-}