querysub 0.309.0 → 0.311.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.309.0",
+  "version": "0.311.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -22,7 +22,7 @@
     "js-sha512": "^0.9.0",
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
-    "socket-function": "^0.135.0",
+    "socket-function": "^0.136.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.22.0",
     "yaml": "^2.5.0",

package/spec.txt

@@ -52,6 +52,26 @@ More corruption resistance files
                 - and... we might as well add support for short, int, float, and uint (uint is a good way to store a guid, via storing 8 uint variables).
 
 Schema/binary PathValues accesses
+        0) First our stream/schema wrappers. Which at first just convert to raw path reads/writes, but once we add schemas they can efficiently create/use those
+        1) PathValue.path (string[]), need to be converted to an opaque type `Path`
+            - Helpers to manipulate it, and go back to string[], string, etc.
+        2) Have Path be able to store itself in schema + variables mode
+            - Where schema is shared across all Path instances
+            { schema: { path: (string|Variable)[] }; variables: (string | number)[]; }
+            - Add functions to access the schema and variable values
+        3) Create an efficient `Map<Path, T>`, via using schemas from the paths
+            - By requiring Path as the input we can directly use the schema to narrow down the cases, and then within that we just have to lookup values by variables
+        4) Use Path everywhere, replacing PathValue.path, using our efficient lookup to manage it.
+            - I think a lookup should handle all the cases. We should be able to nest them as well?
+        5) This SHOULD let us entirely get rid of path joining, which should be SO much faster.
+        6) Update serialization to keep schemas, instead of converting them back to paths. This should be more efficient, and a lot smaller.
+            - Values serialization won't change, and we still need to encode the variables, but... it should still be a lot faster.
+        7) Try to remove as many Path conversions to string (and also to a lesser degree string[]), as possible, by making them schema aware.
+        8) Investigate further optimizations
+            - Replacing variables with numbers, so we our internals Maps can be replaced with arrays / typed arrays
+
+    IMPORTANT! Actually... a lot of the following is wrong. We should have this PER atomic value, and perhaps ONLY for paths!
+
     Base code
         reader
             let viewTime = 0;
@@ -67,9 +87,11 @@ Schema/binary PathValues accesses
     Schema optimization
         writer
             let changeStream = new SchemaPath(() => global().users[wildcard].viewTime);
-            for (let [video, viewTime] of viewedVideos) {
-                changeStream.write(userId, viewTime);
-            }
+            write(() => {
+                for (let [video, viewTime] of viewedVideos) {
+                    changeStream.write(userId, viewTime);
+                }
+            })
         reader
             let schemaWatcher = new SchemaPath(() => global().users[wildcard].viewTime);
             watch(() => {
@@ -108,6 +130,7 @@ Schema/binary PathValues accesses
     - We also need to support partial key watching. Often we will watch a few keys (and then within them, maybe all keys at another level).
 
     1) START by supporting write streams (but NOT read schemas), as this allows us to define our schemas.
+        IMPORTANT! Actually... a lot of the following is wrong. We should have this PER atomic value, and perhaps ONLY for paths!
         - This will give us a big chunk, which we will pass around (even passing around arrays of chunks).
             - The core will break this apart somewhat, with an object per schema, and then a tree of maps for the dynamicValues inside of it (and global lookups for the locks and values)
         - We will never create this from PathValues, instead, we will append values to specific schemas as we build it

package/src/1-path-client/pathValueClientWatcher.ts

@@ -87,7 +87,8 @@ export class ClientWatcher {
 
     /** How long we keep watching, despite a value no longer being needed. */
     public static WATCH_STICK_TIME = MAX_CHANGE_AGE * 2;
-    public static MAX_TRIGGER_TIME = 1000 * 5;
+    public static MAX_TRIGGER_TIME_BROWSER = 1000 * 5;
+    public static MAX_TRIGGER_TIME_NODEJS = 1000 * 300;
 
 
     private valueFunctionWatchers = registerResource("paths|valueFunctionWatchers", new Map<string, Map<WatchSpec["callback"], WatchSpec>>());
@@ -270,6 +271,7 @@ export class ClientWatcher {
                 logErrors(e);
             }
         }
+        let MAX_TRIGGER_TIME = isNode() ? ClientWatcher.MAX_TRIGGER_TIME_NODEJS : ClientWatcher.MAX_TRIGGER_TIME_BROWSER;
 
         let time = Date.now();
         while (true) {
@@ -374,7 +376,7 @@ export class ClientWatcher {
                     this.activeWatchSpec = undefined;
                 }
                 if (
-                    Date.now() - time > ClientWatcher.MAX_TRIGGER_TIME
+                    Date.now() - time > MAX_TRIGGER_TIME
                     && !isDevDebugbreak()
                 ) {
                     stoppedEarly = true;

package/src/2-proxy/schema2.ts

@@ -1,5 +1,5 @@
 import { cache } from "socket-function/src/caching";
-import { nextId, recursiveFreeze } from "socket-function/src/misc";
+import { nextId, recursiveFreeze, sort } from "socket-function/src/misc";
 import { canHaveChildren } from "socket-function/src/types";
 import { isDefined } from "../misc";
 
@@ -109,9 +109,8 @@ type TypeDefType<T = never, Optional = false> = {
      *      the resulting fields, or check a specific field, etc).
      */
     atomicOnlyOnWrite<NewT>(defaultValue?: T | NewT): TypeDefType<T | NewT>;
-    /** Lookups behave as expected with respect to delete, even if the entries are not atomic.
-     *      As in, `delete lookup["a"]` will mean `lookup["a"] === undefined`, even
-     *          if there are nested non-atomic values in the lookup.
+    /** Lookups only return undefined if the entry is a single atomic value. However, their keys work as expected, so you can us "in" to check for keys, delete to remove them an Object.keys() to get the values
+     *      - undefined is not supported as a value, and will return false for "in" and Object.keys (deleting is mapped to setting to undefined).
      * 
      *  NOTE: There is no array. We don't support synchronized arrays. Use an object instead,
      *      even using numbers as keys if you want (they'll be casted to strings, but at least
@@ -244,8 +243,207 @@ export class Schema2Fncs {
             };
         }).filter(isDefined);
     }
+    public static schema2ToTypeString(schema: Schema2): string {
+        return schema2ToTypeString(schema);
+    }
 }
 
+/*
+todonext
+- Fix t.lookup types
+*/
+
+// #region schema2ToTypeString
+/*
+{
+    x: t.number,
+}
+=>
+`{
+    x: number;
+}`
+*/
+export function schema2ToTypeString(schema: Schema2): string {
+    type TypePathValue = {
+        path: string[];
+        type: string;
+        isOptional: boolean;
+    };
+
+    // Step 1: Transform defs to type path values (direct transformation)
+    let type = typeDefCached(schema);
+    let typePathValues: TypePathValue[] = [];
+
+    //return JSON.stringify(type.defs, null, 4);
+
+    for (let def of type.defs) {
+        // Convert path from SchemaPath to string[], replacing WildCard with actual string representation
+        let stringPath = def.path.map(p => p === WildCard ? "*" : p as string);
+
+        // Determine the type based on the def properties
+        let typeStr = "unknown";
+        if (def.isNotAtomic === false || def.defaultValue !== undefined) {
+            // This is a primitive type, determine which one based on default value
+            if (def.isNumber) {
+                typeStr = "number";
+            } else if (def.isString) {
+                typeStr = "string";
+            } else if (def.isBoolean) {
+                typeStr = "boolean";
+            } else if (def.isNull) {
+                typeStr = "null";
+            } else {
+                // For atomic types with complex default values, inspect the type
+                let defaultResult = defaultToType(def.defaultValue);
+                if (typeof defaultResult === "string") {
+                    typeStr = defaultResult;
+                } else {
+                    // It's an array of nested types, add them to our list with prepended paths
+                    typeStr = "object"; // Will be clobbered by nested types
+                    for (let nestedType of defaultResult) {
+                        typePathValues.push({
+                            path: [...stringPath, ...nestedType.path],
+                            type: nestedType.type,
+                            isOptional: nestedType.isOptional
+                        });
+                    }
+                }
+            }
+        }
+
+        typePathValues.push({
+            path: stringPath,
+            type: typeStr,
+            isOptional: !!def.isMaybeUndefined || !def.isNotAtomic && def.defaultValue === undefined
+        });
+    }
+    // Shortest first, so they get clobbered properly.
+    sort(typePathValues, x => x.path.length);
+
+    // Step 2: Build object from type path values
+    type TypeStructure = string | { [key: string]: TypeStructure };
+
+    function buildObjectFromTypePathValues(values: TypePathValue[]): TypeStructure {
+        let result: { [key: string]: TypeStructure } = {};
+
+        for (let value of values) {
+            let current: { [key: string]: TypeStructure } = result;
+            let path = value.path;
+
+            // Navigate/create the nested structure
+            for (let i = 0; i < path.length - 1; i++) {
+                let key = path[i];
+                if (!(key in current)) {
+                    current[key] = {};
+                } else if (typeof current[key] === "string") {
+                    // If there's a conflict (existing string type), convert to object
+                    current[key] = {};
+                }
+                current = current[key] as { [key: string]: TypeStructure };
+            }
+
+            // Set the final value
+            if (path.length > 0) {
+                let finalKey = path[path.length - 1];
+                if (value.isOptional) {
+                    finalKey += "?";
+                }
+                let typeValue = value.type;
+
+                current[finalKey] = `__TYPE_START__${typeValue}__TYPE_END__`;
+            }
+        }
+
+        return result;
+    }
+
+    let objectStructure = buildObjectFromTypePathValues(typePathValues);
+
+    let jsonString = JSON.stringify(objectStructure, null, 4);
+
+    jsonString = jsonString.replace(/"__TYPE_START__(.*?)__TYPE_END__"/g, "$1");
+
+    jsonString = jsonString.replaceAll(`"*":`, "[key: string]:");
+
+    jsonString = jsonString.replace(/"([^"]+)":/g, "$1:");
+
+    // Strip semicolons, because it's too hard to add them all the places they should be, so it's better to just never have them.
+    jsonString = jsonString.replace(/,(\s*\n)/g, "$1");
+
+    return jsonString;
+
+    function defaultToType(defaultValue: unknown): string | TypePathValue[] {
+        if (typeof defaultValue === "number") {
+            return "number";
+        } else if (typeof defaultValue === "string") {
+            return "string";
+        } else if (typeof defaultValue === "boolean") {
+            return "boolean";
+        } else if (defaultValue === null) {
+            return "null";
+        } else if (defaultValue === undefined) {
+            return "undefined";
+        } else if (typeof defaultValue === "object" && defaultValue !== null) {
+            // Handle nested objects
+            let nestedTypes: TypePathValue[] = [];
+            for (let [key, value] of Object.entries(defaultValue)) {
+                let nestedResult = defaultToType(value);
+                if (typeof nestedResult === "string") {
+                    nestedTypes.push({
+                        path: [key],
+                        type: nestedResult,
+                        isOptional: false // nested object values are not optional by default
+                    });
+                } else {
+                    // It's an array, so we need to prepend key to all paths
+                    for (let nested of nestedResult) {
+                        nestedTypes.push({
+                            path: [key, ...nested.path],
+                            type: nested.type,
+                            isOptional: nested.isOptional
+                        });
+                    }
+                }
+            }
+            return nestedTypes;
+        } else {
+            return "unknown";
+        }
+    }
+}
+
+// export let defaultVoiceParameters: VoiceParameters = {
+//     model: "fish-32129816c2e5474494e9dba4d9e92d1f",
+//     speed: 1,
+//     volumeAdjust: 0,
+//     // 1-6 supports (break) and (long-break), amongst others (see https://docs.fish.audio/text-to-speech/fine-grained-control)
+//     ttsModel: "speech-1.6",
+//     temperature: 0.7,
+//     top_p: 0.7,
+//     seed: 0,
+// };
+// export const characterVoice = {
+//     id: t.string,
+//     name: t.string,
+//     description: t.string,
+//     defaultParameters: t.atomic<VoiceParameters>(defaultVoiceParameters),
+//     public: t.boolean,
+//     deleted: t.boolean,
+//     // hashes of samples
+//     samples: t.atomic<string[]>([]),
+//     test: t.lookup({
+//         x: t.number,
+//         xOptional: t.numberOptional,
+//         nested: t.lookup({
+//             y: t.number,
+//             yOptional: t.numberOptional,
+//             defaultParameters: t.atomic<VoiceParameters>(defaultVoiceParameters),
+//         })
+//     })
+// };
+
+
+// #endregion
 
 
 // #region Implementation
@@ -288,8 +486,6 @@ function typeDefProxy(typeDef: TypeDefValues) {
 
 
 type InternalTypeDef = {
-    // NOTE: We don't store primitives, because, 1, we don't need to, and 2, because
-    //  they could be added with the .type<number>() call, at which point we can't track them.
     path: SchemaPath;
     atomicOnlyOnWrite?: boolean;
 
@@ -299,6 +495,11 @@ type InternalTypeDef = {
 
     isNotAtomic?: boolean;
 
+    isNumber?: boolean;
+    isString?: boolean;
+    isBoolean?: boolean;
+    isNull?: boolean;
+
     gcDelay?: number;
 
     defaultValue?: unknown;
@@ -316,6 +517,7 @@ function typeDefTypeToInternalType(
     initialValues?: Partial<InternalTypeDef>
 ): InternalTypeDef[] {
     let rootResult: InternalTypeDef = { path, ...initialValues };
+
     // NOTE: By default functions cause atomic behavior ("atomic", "type", etc), and don't need special handler
     //      Most of the overloads are for purely type behavior, and not runtime behavior (or just
     //      for nice aliases, so it is more clear what the functions do).
@@ -416,6 +618,20 @@ function typeDefTypeToInternalType(
         //  - Basically, we often store very large objects in state, under the expectation it is never traversed. While defaults might not be large, the expectation that it isn't traversed is still there, and if we traverse it and freeze it, we are likely to break things.
         rootResult.defaultValue = params[params.length - 1]?.callParams?.[0] ?? baseDefault;
     }
+
+    if (typeDef.path.some(x => x.includes("number")) || typeof rootResult.defaultValue === "number") {
+        rootResult.isNumber = true;
+    }
+    if (typeDef.path.some(x => x.includes("string")) || typeof rootResult.defaultValue === "string") {
+        rootResult.isString = true;
+    }
+    if (typeDef.path.some(x => x.includes("boolean")) || typeof rootResult.defaultValue === "boolean") {
+        rootResult.isBoolean = true;
+    }
+    if (typeDef.path.some(x => x.includes("null")) || rootResult.defaultValue === null) {
+        rootResult.isNull = true;
+    }
+
     return results;
 }
 function getTypeDefValues(typeDef: TypeDefObj) {

package/src/4-querysub/Querysub.ts

@@ -3,6 +3,10 @@
 //  a file prevents it from transforming it, so we'll miss a lot of files doing it this late).
 import "../inject";
 
+// Shim Promise.race, as no one wants their promises to leak...
+import { promiseRace } from "socket-function/src/promiseRace";
+Promise.race = promiseRace;
+
 import { shimDateNow } from "socket-function/time/trueTimeShim";
 shimDateNow();
 
@@ -56,6 +60,7 @@ typesafecss.setDelayFnc(async fnc => {
     fnc();
 });
 
+
 export { t };
 
 let yargObj = parseArgsFactory()
@@ -191,10 +196,6 @@ export class Querysub {
      */
     public static MAX_FUTURE_CALL_TIME = 10_000;
 
-    /** Maximum amount of synchronous time spend handling triggered operations until we
-     *      abort them (with an error).
-     */
-    public static SET_MAX_TRIGGER_TIME = (value: number) => ClientWatcher.MAX_TRIGGER_TIME = value;
 
     /** Compression makes serialization about 2X slower, but reduces the size by about 2X (more or less if your
      *      data size is dominated by value size instead of key size). */
@@ -415,9 +416,13 @@ export class Querysub {
         if (!proxyWatcher.getTriggeredWatcherMaybeUndefined()) {
             void Promise.resolve().finally(callback);
         } else if (proxyWatcher.getTriggeredWatcher().options.temporary) {
-            proxyWatcher.getTriggeredWatcher().onInnerDisposed.push(callback);
+            let innerDisposed = proxyWatcher.getTriggeredWatcher().onInnerDisposed;
+            if (innerDisposed.includes(callback)) return;
+            innerDisposed.push(callback);
         } else {
-            proxyWatcher.getTriggeredWatcher().onAfterTriggered.push(callback);
+            let afterTriggered = proxyWatcher.getTriggeredWatcher().onAfterTriggered;
+            if (afterTriggered.includes(callback)) return;
+            afterTriggered.push(callback);
         }
     }
     public static onCommitFinishedCommit(callback: () => void) {

package/src/5-diagnostics/Modal.tsx

@@ -63,8 +63,11 @@ export class Modal extends qreact.Component<{
 function closeModal(id: string) {
     let modelObj = data().modals[id];
     if (!modelObj) return;
-    let result = modelObj.onClose?.();
-    if (result === "abortClose") return;
+    let onClose = modelObj.onClose;
+    if (typeof onClose === "function") {
+        let result = onClose();
+        if (result === "abortClose") return;
+    }
     delete data().modals[id];
 }
 

package/src/5-diagnostics/memoryValueAudit.ts

@@ -277,54 +277,52 @@ async function auditSpecificPathsBase(config: {
         let reason = remoteWatcher.getWatchReason(path);
         if (!reason) continue;
 
-        if (isDevDebugbreak()) {
-            const ourNodeId = getOwnNodeId();
-            let logs: DebugLog[] = [];
-            let remoteLogs: DebugLog[] = [];
-            // NOTE: Actually, even if we included it because of a parent watch, we still only
-            //      care about direct writes to this value.
-            if (reason === "parent") {
-                logs = getLogHistoryIncludes(path);
-                remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
-
-                let logs2 = getLogHistoryIncludes(getParentPathStr(path));
-                let remoteLogs2 = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(getParentPathStr(path));
-                logs.push(...logs2);
-                remoteLogs.push(...remoteLogs2);
-            } else {
-                logs = getLogHistoryEquals(path);
-                remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
-            }
-            let atTime = Date.now();
-            console.error(`Audit mismatch for ${path} from ${authorityNodeId} detected at ${atTime}. Watching because: ${reason}`);
-            console.log(`Value Remote (${value?.valid ? "valid" : "invalid"}):`, pathValueSerializer.getPathValue(value));
-            console.log(`Value Local (${ourValue?.valid ? "valid" : "invalid"}):`, pathValueSerializer.getPathValue(ourValue));
-            console.log(`Time Remote:`, value?.time.time);
-            console.log(`Time Local:`, ourValue?.time.time);
-            console.log(`Our node id:`, ourNodeId);
-            console.log(`Time now:`, atTime);
-            console.log();
-            let logObjs: { source: string, log: DebugLog }[] = [];
-            for (let log of logs) {
-                logObjs.push({ source: "local", log });
-            }
-            for (let log of remoteLogs) {
-                logObjs.push({ source: "remote", log });
-            }
-            sort(logObjs, x => x.log.time);
-            let now = Date.now();
-            for (let { source, log } of logObjs.slice(-100)) {
-                console.log(`${source.padEnd(8, " ")} ${log.type.padEnd(20, " ")}`, now - log.time, log.values, log.time);
-            }
-            debugbreak(2);
-            debugger;
-            console.log(path);
-            console.log(value);
-            console.log(ourValue);
-            console.log(logs.length);
-            console.log(remoteLogs.length);
-            console.log(atTime);
-        }
+        // if (isDevDebugbreak()) {
+        //     const ourNodeId = getOwnNodeId();
+        //     let logs: DebugLog[] = [];
+        //     let remoteLogs: DebugLog[] = [];
+        //     // NOTE: Actually, even if we included it because of a parent watch, we still only
+        //     //      care about direct writes to this value.
+        //     if (reason === "parent") {
+        //         logs = getLogHistoryIncludes(path);
+        //         remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
+
+        //         let logs2 = getLogHistoryIncludes(getParentPathStr(path));
+        //         let remoteLogs2 = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(getParentPathStr(path));
+        //         logs.push(...logs2);
+        //         remoteLogs.push(...remoteLogs2);
+        //     } else {
+        //         logs = getLogHistoryEquals(path);
+        //         remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
+        //     }
+        //     let atTime = Date.now();
+        //     console.error(`Audit mismatch for ${path} from ${authorityNodeId} detected at ${atTime}. Watching because: ${reason}`);
+        //     console.log(`Value Remote (${value?.valid ? "valid" : "invalid"}):`, pathValueSerializer.getPathValue(value));
+        //     console.log(`Value Local (${ourValue?.valid ? "valid" : "invalid"}):`, pathValueSerializer.getPathValue(ourValue));
+        //     console.log(`Time Remote:`, value?.time.time);
+        //     console.log(`Time Local:`, ourValue?.time.time);
+        //     console.log(`Our node id:`, ourNodeId);
+        //     console.log(`Time now:`, atTime);
+        //     console.log();
+        //     let logObjs: { source: string, log: DebugLog }[] = [];
+        //     for (let log of logs) {
+        //         logObjs.push({ source: "local", log });
+        //     }
+        //     for (let log of remoteLogs) {
+        //         logObjs.push({ source: "remote", log });
+        //     }
+        //     sort(logObjs, x => x.log.time);
+        //     let now = Date.now();
+        //     for (let { source, log } of logObjs.slice(-100)) {
+        //         console.log(`${source.padEnd(8, " ")} ${log.type.padEnd(20, " ")}`, now - log.time, log.values, log.time);
+        //     }
+        //     console.log(path);
+        //     console.log(value);
+        //     console.log(ourValue);
+        //     console.log(logs.length);
+        //     console.log(remoteLogs.length);
+        //     console.log(atTime);
+        // }
         auditLog("Failed memory audit", { path, value, ourValue });
 
         invalidValues.add(path);

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -19,17 +19,9 @@ import { StickyBottomScroll } from "../../library-components/StickyBottomScroll"
 import { PrimitiveDisplay } from "../../diagnostics/logs/ObjectDisplay";
 import { parseAnsiColors, rgbToHsl } from "../../diagnostics/logs/ansiFormat";
 import { RenderGitRefInfo, UpdateServiceButtons, bigEmoji, buttonStyle } from "./deployButtons";
+import { TypedConfigEditor } from "../../library-components/TypedConfigEditor";
+
 
-// Type declarations for Monaco editor
-declare global {
-    interface Window {
-        monaco: any;
-        require: {
-            config: (options: any) => void;
-            (modules: string[], callback: () => void): void;
-        };
-    }
-}
 
 export class ServiceDetailPage extends qreact.Component {
     state = t.state({
@@ -46,64 +38,12 @@ export class ServiceDetailPage extends qreact.Component {
         }),
     });
 
-    private async ensureMonacoLoaded(): Promise<void> {
-        // If Monaco is already loaded, return immediately
-        if (window.monaco) {
-            return;
-        }
-
-        // Load Monaco from CDN
-        return new Promise<void>((resolve, reject) => {
-            const script = document.createElement("script");
-            script.src = "https://unpkg.com/monaco-editor@0.44.0/min/vs/loader.js";
-            script.onload = () => {
-                window.require.config({ paths: { vs: "https://unpkg.com/monaco-editor@0.44.0/min/vs" } });
-                window.require(["vs/editor/editor.main"], () => {
-                    resolve();
-                });
-            };
-            script.onerror = () => {
-                reject(new Error("Failed to load Monaco editor"));
-            };
-            document.head.appendChild(script);
-        });
-    }
-
-    private setupMonacoWithTypes(serviceConfigType: string): string {
-        // Configure TypeScript compiler options - turn off default libs
-        window.monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
-            target: window.monaco.languages.typescript.ScriptTarget.ES2022,
-            strict: true,
-            lib: [] // Turn off all default libs
-        });
-
-        // Add global ServiceConfig type declaration
-        const globals = `
-type ServiceConfig = ${serviceConfigType}
-`;
-
-        window.monaco.languages.typescript.typescriptDefaults.addExtraLib(
-            globals,
-            "serviceconfig-types.d.ts"
-        );
 
-        return globals;
-    }
 
     private updateUnsavedChanges(updatedConfig: ServiceConfig) {
         // Do not let them update the serviceId, as that would break things
         updatedConfig.serviceId = selectedServiceIdParam.value;
-        const newConfigStr = JSON.stringify(updatedConfig, null, 4);
         this.state.unsavedChanges = updatedConfig;
-
-        // Update Monaco model if it exists
-        const configUri = window.monaco?.Uri?.parse("inmemory://model/serviceconfig.ts");
-        if (configUri && window.monaco?.editor) {
-            const model = window.monaco.editor.getModel(configUri);
-            if (model) {
-                model.setValue(`const config: ServiceConfig = ${newConfigStr}`);
-            }
-        }
     }
     private updateConfigSynced(updatedConfig: ServiceConfig) {
         Querysub.onCommitFinished(() => {
@@ -174,16 +114,6 @@ type ServiceConfig = ${serviceConfigType}
 
         Querysub.onCommitFinished(async () => {
             try {
-
-                // Update Monaco model with new config
-                const newConfigStr = JSON.stringify(updatedConfig, null, 4);
-                const configUri = window.monaco?.Uri?.parse("inmemory://model/serviceconfig.ts");
-                if (configUri && window.monaco?.editor) {
-                    const model = window.monaco.editor.getModel(configUri);
-                    if (model) {
-                        model.setValue(`const config: ServiceConfig = ${newConfigStr}`);
-                    }
-                }
                 await MachineServiceController(SocketFunction.browserNodeId()).setServiceConfigs.promise([updatedConfig]);
             } catch (error) {
                 Querysub.localCommit(() => {
@@ -502,16 +432,6 @@ type ServiceConfig = ${serviceConfigType}
                         className={css.pad2(12, 8).button.bord2(0, 0, 20).hsl(50, 80, 50)}
                         onClick={() => {
                             this.state.unsavedChanges = undefined;
-
-                            // Update Monaco editor with original config
-                            const newConfigStr = JSON.stringify(originalConfig, null, 4);
-                            const configUri = window.monaco?.Uri?.parse("inmemory://model/serviceconfig.ts");
-                            if (configUri && window.monaco?.editor) {
-                                const model = window.monaco.editor.getModel(configUri);
-                                if (model) {
-                                    model.setValue(`const config: ServiceConfig = ${newConfigStr}`);
-                                }
-                            }
                         }}>
                         Discard Changes
                     </button>
@@ -605,75 +525,15 @@ type ServiceConfig = ${serviceConfigType}
                 </div>
             )}
 
-            {/* Monaco Editor */}
-            <div key="editor" ref2={async element => {
-                if (!element) return;
-                let editorElement = element.children[0] as HTMLElement;
-
-                Querysub.onCommitFinished(async () => {
-
-                    // Ensure Monaco is loaded
-                    await this.ensureMonacoLoaded();
-
-                    // Setup TypeScript with ServiceConfig type
-                    const typeDeclarations = this.setupMonacoWithTypes(serviceConfigType!);
-
-                    const configStr = JSON.stringify(config, null, 4);
-
-                    // Create hidden model for the type definitions
-                    const typeUri = window.monaco.Uri.parse("inmemory://model/serviceconfig-types.d.ts");
-                    let typeModel = window.monaco.editor.getModel(typeUri);
-                    if (!typeModel) {
-                        window.monaco.editor.createModel(typeDeclarations, "typescript", typeUri);
-                    }
-
-                    // Create a TypeScript model with clean config assignment
-                    const configUri = window.monaco.Uri.parse("inmemory://model/serviceconfig.ts");
-                    let model = window.monaco.editor.getModel(configUri);
-                    if (model) {
-                        // Update existing model content
-                        model.setValue(`const config: ServiceConfig = ${configStr}`);
-                    } else {
-                        // Create new model
-                        model = window.monaco.editor.createModel(
-                            `const config: ServiceConfig = ${configStr}`,
-                            "typescript",
-                            configUri
-                        );
-                    }
-
-                    // Create the editor
-                    const editor = window.monaco.editor.create(editorElement, {
-                        model: model,
-                        theme: "vs-dark",
-                        automaticLayout: true,
-                        minimap: { enabled: false },
-                        wordWrap: "on",
-                    });
-
-                    // Listen for changes
-                    editor.onDidChangeModelContent(() => {
-                        const value = editor.getValue();
-                        const configMatch = value.match(/const config: ServiceConfig = ([\s\S]*)/);
-                        if (configMatch) {
-                            try {
-                                // Try to parse the JSON
-                                const parsedConfig = JSON.parse(configMatch[1]);
-                                Querysub.localCommit(() => {
-                                    this.state.unsavedChanges = parsedConfig;
-                                });
-                            } catch (error) {
-                                // Ignore parsing errors, keep previous unsavedChanges
-                            }
-                        }
-                    });
-                });
-            }}>
-                <div style={{
-                    width: `${Math.min(window.innerWidth - 100, 1000)}px`,
-                    height: "600px"
-                }} />
-            </div>
+            {/* Config Editor */}
+            <TypedConfigEditor
+                value={config}
+                onValueChange={(newValue) => {
+                    this.state.unsavedChanges = newValue as ServiceConfig;
+                }}
+                typeDefinition={serviceConfigType}
+                sizeClassName={css.size(1000, 600)}
+            />
         </div>;
     }
 } 

package/src/deployManager/machineApplyMainCode.ts

@@ -413,7 +413,7 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
             rollingObj.pinnedDuration = config.rollingWindow;
         }
         let existingScreen = screens.find(x => x.screenName === screenName);
-        if (existingScreen && !rollingObj) {
+        if (existingScreen && !rollingObj && await isScreenRunningProcess(existingScreen.pid)) {
             let nodeIdPath = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/" + SERVICE_NODE_FILE_NAME;
             let rollingFinalTime = Date.now() + config.rollingWindow;
             if (fs.existsSync(nodeIdPath)) {
@@ -668,7 +668,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                     continue;
                 }
 
-                console.log(`Resyncing service ${magenta(screenName)}, with ${JSON.stringify(config.parameters)}`);
+                console.log(`Resyncing service ${magenta(screenName)}, with ${JSON.stringify(config.parameters)}, isRunning = ${screenIsRunning}, sameParameters = ${sameParameters}`);
 
                 await fs.promises.writeFile(parameterPath, newParametersString);
 
@@ -728,7 +728,7 @@ const resyncServicesBase = runInSerial(measureWrap(async function resyncServices
                 rollingInfo = undefined;
             }
             if (rollingInfo) {
-                console.log(green(`Skipping killing rolling screen ${screenName} because it's still alive at ${new Date().toLocaleString()}. Keeping it alive until ${new Date(rollingInfo.pinnedTime + rollingInfo.pinnedDuration).toLocaleString()}`));
+                console.log(green(`Skipping killing rolling screen ${screenName} because it's still alive at ${new Date().toLocaleString()}. Keeping it alive until ${new Date(rollingInfo.pinnedTime + rollingInfo.pinnedDuration).toLocaleString()}. Was pinned at ${new Date(rollingInfo.pinnedTime).toLocaleString()}, rolling duration is ${formatTime(rollingInfo.pinnedDuration)}`));
                 continue;
             }
         }

package/src/diagnostics/logs/diskLogger.ts

@@ -312,7 +312,7 @@ if (isNode()) {
         }
     });
     // Wait a random time, so we hopefully don't synchronize with any other services on this machine
-    runInfinitePoll(timeInHour + (1 + Math.random()), async function compressOldLogs() {
+    runInfinitePoll(timeInHour * (1 + Math.random()), async function compressOldLogs() {
         let logFiles = await fs.promises.readdir(folder);
         let compressTime = Date.now() - LOG_FILE_DURATION * 2;
         let filesCompressed = 0;

package/src/library-components/Button.tsx

@@ -112,6 +112,7 @@ export function triggerKeyDown(e: KeyboardEvent, forceAmbient = true) {
 
     function trigger(keyFull: string) {
         keyFull = keyFull.toLowerCase();
+        console.log(`Triggering hotkey ${keyFull}`);
         let listeners = Array.from(registeredWatches).map(x => {
             let props = Querysub.localRead(() => ({ ...x.props }), { allowProxyResults: true });
             let match = props.hotkeys?.find(x => {

package/src/library-components/TypedConfigEditor.tsx

@@ -0,0 +1,205 @@
+import { qreact } from "../4-dom/qreact";
+import { t } from "../2-proxy/schema2";
+import { css } from "typesafecss";
+import { Querysub } from "../4-querysub/QuerysubController";
+
+// Type declarations for Monaco editor
+declare global {
+    interface Window {
+        monaco: any;
+        require: {
+            config: (options: unknown) => void;
+            (modules: string[], callback: () => void): void;
+        };
+    }
+}
+
+
+export interface TypedConfigEditorProps {
+    value: any;
+    onValueChange?: (newValue: unknown) => void;
+    /**
+      Ex:
+        {
+            x: number;
+            y?: string;
+        }
+     */
+    typeDefinition: string;
+    sizeClassName?: string;
+}
+
+
+let nextSeqNum = Math.floor(Date.now() / 1000);
+export class TypedConfigEditor extends qreact.Component<TypedConfigEditorProps> {
+    state = t.state({
+        editorReady: t.type(false),
+        currentValue: t.type<any>(undefined)
+    });
+
+    private editor: any = null;
+    private model: any = null;
+    private uniqueId = nextSeqNum++;
+
+    private typeName = `Type${this.uniqueId}`;
+    private valueName = `config${this.uniqueId}`;
+
+
+    private async ensureMonacoLoaded(): Promise<void> {
+        // If Monaco is already loaded, return immediately
+        if (window.monaco) {
+            return;
+        }
+
+        // Load Monaco from CDN
+        return new Promise<void>((resolve, reject) => {
+            const script = document.createElement("script");
+            script.src = "https://unpkg.com/monaco-editor@0.44.0/min/vs/loader.js";
+            script.onload = () => {
+                window.require.config({ paths: { vs: "https://unpkg.com/monaco-editor@0.44.0/min/vs" } });
+                window.require(["vs/editor/editor.main"], () => {
+                    resolve();
+                });
+            };
+            script.onerror = () => {
+                reject(new Error("Failed to load Monaco editor"));
+            };
+            document.head.appendChild(script);
+        });
+    }
+
+    private setupMonacoWithTypes(typeDefinition: string, typeName: string): void {
+        // Configure TypeScript compiler options - turn off default libs
+        window.monaco.languages.typescript.typescriptDefaults.setCompilerOptions({
+            target: window.monaco.languages.typescript.ScriptTarget.ES2022,
+            strict: true,
+            lib: [] // Turn off all default libs
+        });
+
+        // Add type declarations
+        window.monaco.languages.typescript.typescriptDefaults.addExtraLib(
+            typeDefinition,
+            `${typeName.toLowerCase()}-types.d.ts`
+        );
+    }
+
+    private updateEditorValue(value: any): void {
+        if (!this.model) return;
+
+        const valueStr = JSON.stringify(value, null, 4);
+        const content = `const ${this.valueName}: ${this.typeName} = ${valueStr}`;
+
+        // Only update if content has changed to avoid cursor jumping
+        if (this.model.getValue() !== content) {
+            this.model.setValue(content);
+        }
+    }
+
+    componentDidMount(): void {
+        this.state.currentValue = this.props.value;
+    }
+
+    componentDidUpdate(prevProps: TypedConfigEditorProps): void {
+        // Update editor if value changed from props
+        if (this.props.value !== prevProps.value && this.props.value !== this.state.currentValue) {
+            this.state.currentValue = this.props.value;
+            this.updateEditorValue(this.props.value);
+        }
+    }
+
+    componentWillUnmount(): void {
+        if (this.editor) {
+            this.editor.dispose();
+        }
+        if (this.model) {
+            this.model.dispose();
+        }
+    }
+
+    render() {
+        let typeName = this.typeName;
+        let valueName = this.valueName;
+        let typeDefinition = `type ${typeName} = ${this.props.typeDefinition}`;
+
+        return <div
+            key={"Editor-" + this.uniqueId}
+            ref2={async element => {
+                if (!element) return;
+                let editorElement = element.children[0] as HTMLElement;
+
+                Querysub.onCommitFinished(async () => {
+                    // Ensure Monaco is loaded
+                    await this.ensureMonacoLoaded();
+
+                    // Setup TypeScript with custom types
+                    this.setupMonacoWithTypes(typeDefinition, typeName);
+
+                    let propsValue = Querysub.localRead(() => this.props.value);
+                    let valueStr = JSON.stringify(propsValue, null, 4);
+
+                    // Create hidden model for the type definitions
+                    const typeUri = window.monaco.Uri.parse(`inmemory://model/${this.uniqueId}-${typeName.toLowerCase()}-types.d.ts`);
+                    let typeModel = window.monaco.editor.getModel(typeUri);
+                    if (!typeModel) {
+                        window.monaco.editor.createModel(typeDefinition, "typescript", typeUri);
+                    }
+
+                    // Create a TypeScript model with clean config assignment
+                    const configUri = window.monaco.Uri.parse(`inmemory://model/${this.uniqueId}-${valueName}.ts`);
+                    this.model = window.monaco.editor.getModel(configUri);
+                    if (this.model) {
+                        // Update existing model content
+                        this.updateEditorValue(propsValue);
+                    } else {
+                        // Create new model
+                        this.model = window.monaco.editor.createModel(
+                            `const ${valueName}: ${typeName} = ${valueStr}`,
+                            "typescript",
+                            configUri
+                        );
+                    }
+
+                    // Create the editor
+                    this.editor = window.monaco.editor.create(editorElement, {
+                        model: this.model,
+                        theme: "vs-dark",
+                        automaticLayout: true,
+                        minimap: { enabled: false },
+                        wordWrap: "on",
+                    });
+
+                    // Listen for changes
+                    this.editor.onDidChangeModelContent(() => {
+                        const value = this.editor.getValue();
+                        const configMatch = value.match(new RegExp(`const ${valueName}: ${typeName} = ([\\s\\S]*)`));
+                        if (configMatch) {
+                            try {
+                                // Try to parse the JSON
+                                const parsedValue = JSON.parse(configMatch[1]);
+                                Querysub.localCommit(() => {
+                                    this.state.currentValue = parsedValue;
+                                });
+
+                                Querysub.commit(() => {
+                                    this.props.onValueChange?.(parsedValue);
+                                });
+                            } catch (error) {
+                                // Ignore parsing errors, keep previous value
+                            }
+                        }
+                    });
+
+                    Querysub.localCommit(() => {
+                        this.state.editorReady = true;
+                    });
+                });
+            }}
+        >
+            <div className={css
+                .width(Math.min(window.innerWidth - 100, 600), "soft")
+                .height(Math.min(window.innerHeight - 100, 1000), "soft")
+                + this.props.sizeClassName}
+            />
+        </div>;
+    }
+}

package/src/niceStringify.ts

@@ -11,6 +11,9 @@ export const niceStringifyUndefined = `{Undefined}`;
 // BUG: This is actually broken for hex strings. Hex strings may sometimes be entirely numbers,
 //  which means they will randomly change type.
 function looksLikeJSON(str: string) {
+    let looksLikeNumber = (str: string) => {
+        return str.match(/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/);
+    };
     return (
         str === "null"
         || str === "true"
@@ -18,8 +21,7 @@ function looksLikeJSON(str: string) {
         || str[0] === `"` && str[str.length - 1] === `"`
         || str[0] === `[` && str[str.length - 1] === `]`
         || str[0] === `{` && str[str.length - 1] === `}`
-        || (48 <= str.charCodeAt(0) && str.charCodeAt(0) <= 57)
-        || str.length > 1 && str[0] === "-" && (48 <= str.charCodeAt(1) && str.charCodeAt(1) <= 57)
+        || (48 <= str.charCodeAt(0) && str.charCodeAt(0) <= 57 || str[0] === "-") && looksLikeNumber(str)
         || str === niceStringifyTrue
         || str === niceStringifyUndefined
     );