querysub 0.2.0

package/src/4-querysub/querysubPrediction.ts

@@ -0,0 +1,525 @@
+import { cacheJSONArgsEqual, cacheWeak, lazy } from "socket-function/src/caching";
+import { pathValueCommitter } from "../0-path-value-core/PathValueController";
+import { CLIENTSIDE_PREDICT_LEEWAY, MAX_ACCEPTED_CHANGE_AGE, MAX_CHANGE_AGE, PathValue, ReadLock, Time, authorityStorage, compareTime, debugTime, getCreatorId, getNextTime, lockToCallback, registerIsOurPrediction, timeMinusEpsilon } from "../0-path-value-core/pathValueCore";
+import { remoteWatcher } from "../1-path-client/RemoteWatcher";
+import { proxyWatcher, atomicObjectRead } from "../2-proxy/PathValueProxyWatcher";
+import { getPathFromProxy, getProxyPath } from "../2-proxy/pathValueProxy";
+import { CallSpec, FunctionResult, FunctionSpec, debugCallSpec, functionSchema, overrideCurrentCall } from "../3-path-functions/PathFunctionRunner";
+import { getModuleFromConfig, setGitURLMapping } from "../3-path-functions/pathFunctionLoader";
+import { logErrors } from "../errors";
+import { getParentPathStr, getPathFromStr, getPathStr1, getPathStr2 } from "../path";
+import { Querysub, QuerysubController, baseAddCall, callWaitOn, querysubNodeId } from "./QuerysubController";
+import { Benchmark } from "../diagnostics/benchmark";
+import { parseArgs } from "../3-path-functions/PathFunctionHelpers";
+import { runInSerial } from "socket-function/src/batching";
+import { green, magenta, red, yellow } from "socket-function/src/formatting/logColors";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+
+import { setFlag } from "socket-function/require/compileFlags";
+import cbor from "cbor-x";
+import { FunctionMetadata } from "../3-path-functions/syncSchema";
+import { isNode, nextId, sort } from "socket-function/src/misc";
+setFlag(require, "cbor-x", "allowclient", true);
+const cborEncoder = lazy(() => new cbor.Encoder({ structuredClone: true }));
+
+// TODO: I think our use of filePath, moduleId, etc are wrong here? We give pathFunctionLoader the filePath,
+//  but we really should just give it the moduleId, or... even just avoid calling it altogether, as it doesn't
+//  do too much for us if we already have the fully resolved path...
+//  - Although using it DOES allow permissions checks to work nicely, so, eh... maybe it is fine to use pathFunctionLoader?
+const addModuleToLoader = cacheJSONArgsEqual(async (spec: FunctionSpec): Promise<void> => {
+    let nodeId = await querysubNodeId();
+    if (!nodeId) throw new Error("No querysub node found");
+    let path = await QuerysubController.nodes[nodeId].getModulePath({ functionSpec: spec });
+    setGitURLMapping({ spec, resolvedPath: path });
+});
+
+
+export function getCallResultPath(call: CallSpec) {
+    return getProxyPath(() => functionSchema()[call.DomainName].PathFunctionRunner[call.ModuleId].Results[call.CallId]);
+}
+export function getCallResult(call: CallSpec) {
+    return functionSchema()[call.DomainName].PathFunctionRunner[call.ModuleId].Results[call.CallId];
+}
+
+/** Force predictions to run in the trigger order, so they can resolve an be added before
+ *      the next predictions. Also, to preserve call order.
+ */
+const predictRunCommitLoop = runInSerial((run: () => Promise<PredictResult>) => run());
+
+
+interface DelayedCall {
+    call: CallSpec;
+    time: number;
+    commit: () => void;
+    cancel: () => void;
+
+    result?: PredictResult;
+}
+
+let callPending: DelayedCall[] = [];
+function flushUpToIncluding(time: number) {
+    while (callPending.length > 0) {
+        if (callPending[0].time > time) break;
+        let call = callPending.shift()!;
+        call.commit();
+    }
+}
+
+export function flushDelayedFunctions() {
+    while (callPending.length > 0) {
+        flushUpToIncluding(callPending[callPending.length - 1].time);
+    }
+}
+
+export const addCall = runInSerial(async function addCall(call: CallSpec, metadata: FunctionMetadata) {
+    const nodeId = await querysubNodeId();
+    if (!nodeId) throw new Error("No querysub node found");
+
+    // TODO: Use some heuristics to determine if we should predict the call or not (ex, based on predicted time
+    //  to run, current load, latency to server, time for server to run it, time to sync the necessary data, etc)
+    // TODO: Allow some flags to tell us NOT to predict a call
+    let predict = Querysub.PREDICT_CALLS;
+    if (metadata.nopredict) {
+        predict = false;
+    }
+    let cancel = () => { };
+
+    if (predict) {
+        let delayed = metadata.delayCommit && !isNode();
+        let predictObj = predictCall({ call, localOnly: delayed });
+        cancel = predictObj.cancel;
+        callWaitOn(call.CallId, predictObj.predictPromise);
+        if (metadata.delayCommit && !isNode()) {
+            let hasRun = false;
+            let delayedCall: DelayedCall = {
+                call,
+                time: Date.now(),
+                commit() {
+                    if (hasRun) return;
+                    hasRun = true;
+                    logErrors(baseAddCall(call, nodeId, cancel, `call (delayed from ${debugTime(call.runAtTime)})`));
+                },
+                cancel() { predictObj.cancel(); },
+            };
+            callPending.push(delayedCall);
+            setTimeout(() => flushUpToIncluding(delayedCall.time), Querysub.DELAY_COMMIT_DELAY);
+            logErrors(predictObj.predictPromise.then(async (prediction): Promise<void> => {
+                prediction = { ...prediction };
+                const resultPrefix = getProxyPath(() => functionSchema()[call.DomainName].PathFunctionRunner[call.ModuleId].Results);
+                prediction.writes = prediction.writes.filter(write => !write.path.startsWith(resultPrefix));
+                delayedCall.result = prediction;
+
+                let index = callPending.indexOf(delayedCall);
+                if (index === -1) return;
+                let ourWritePaths = new Set(prediction.writes.map(x => x.path));
+                function candidateCouldBeChangedByWritesSimilarToOurs(candidate: PredictResult) {
+                    return (
+                        candidate.writes.some(write => ourWritePaths.has(write.path))
+                        || candidate.writes.some(write => candidate.readPaths.has(write.path))
+                        || candidate.writes.some(write =>
+                            candidate.readParentPaths.has(getParentPathStr(write.path))
+                            || candidate.readParentPaths.has(write.path)
+                        )
+                    );
+                }
+
+                // NOTE: Technically... we can remove a write if:
+                //  - latest.writes.paths is a superset of candidate.writes.paths
+                //  - (candidate <= intermediate < latest).all(x =>
+                //          test replace writes of x with previous values of x, as time of x
+                //          rerun writes up to and including latest
+                //          verify final resolved writes are equivalent as the final writes as if we had the candidate write
+                //    )
+                // HOWEVER, the last condition is overly arduous to implement, wildly inefficient to calculate, so
+                //      we can simplify it to a more conservative (removes less candidates, but still is never wrong):
+                //  - (candidate < intermediate < latest).all(x => none of x.write.paths are in latest.writes.paths and none of x.read.paths are in latest.writes.paths)
+                //  - candidate.writes.paths is a subset of latest.writes.paths
+                //  -   test replace writes of x with previous values of x, as time of x
+                //      rerun latest
+                //      verify writes2.writes === writes.writes (paths and values)
+                // NOTE: See "delayCommit" in syncSchema for the risks of delaying commits.
+
+                // Find the first write that is a candidate (due to our simplified condition this will only be 1).
+                let curIndex = index - 1;
+                while (curIndex >= 0) {
+                    let candidatePred = callPending[curIndex].result;
+                    if (!candidatePred) {
+                        // NOTE: This shouldn't happen, but if it does... we could just stop searching here, and not
+                        //      remove any predictions.
+                        throw new Error("Predictions finished out of order.");
+                    }
+                    if (candidateCouldBeChangedByWritesSimilarToOurs(candidatePred)) {
+                        break;
+                    }
+                    curIndex--;
+                }
+                // Nothing to remove, we don't overlap any other writes
+                if (curIndex < 0) {
+                    return;
+                }
+
+                let candidate = callPending[curIndex];
+                let candidatePred = candidate.result;
+                if (!candidatePred) {
+                    throw new Error("Predictions finished out of order.");
+                }
+                // candidate writes have to be a strict subset of our writes, otherwise there is no way we will clobber the candidate.
+                if (candidatePred.writes.some(write => !ourWritePaths.has(write.path))) return;
+
+
+                let debugName = `[redundant check]|${call.DomainName}.${call.FunctionId}`;
+                // NOTE: Run right before the call, so we skip it's writes, but use everything else. We could also use
+                //  candidate.time + epsilon, because none of the values between call and candidate matter (they don't write
+                //  to any paths either read from).
+                let beforeCall = { ...call };
+                beforeCall.runAtTime = timeMinusEpsilon(getPredictTime(call.runAtTime));
+                let withoutCandidateResult = await getCallWrites({
+                    call: beforeCall,
+                    debugName,
+                    overrides: candidatePred.replacedWriteValues
+                });
+
+                function areWritesEqual(writes: PathValue[], writes2: PathValue[]) {
+                    if (writes.length !== writes2.length) return false;
+                    // Write order should probably be the same anyways, so... it is far to compare in order
+                    for (let i = 0; i < writes.length; i++) {
+                        let write = writes[i];
+                        let write2 = writes2[i];
+                        if (write.path !== write2.path) return false;
+                        if (pathValueSerializer.compareValuePaths(write, write2) !== 0) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+
+                if (!areWritesEqual(withoutCandidateResult.writes, prediction.writes)) {
+                    if (Querysub.DEBUG_CALLS) {
+                        // Failed to collapse delayed functions, because one of the previous predictions was used in the new predicted function. This is valid, but slower than necessary. If pure atomic behavior is not required (which it presumably isn't required, as delayCommit is already being used), try to rewrite the function to be in the form of a set, instead of an add. For example, "function add(count) { x += count; }" => "function set(value) { x = value; }" (calling with set(x + count)).
+                        console.log(`[Querysub] ${yellow("CANNOT DELAY COLLAPSE")}      ${debugCallSpec(candidate.call)} `);
+                    }
+                    return;
+                }
+
+                let index2 = callPending.indexOf(candidate);
+                if (index2 < 0) return;
+                // At this point... we KNOW:
+                //  a) There are no writes between us and `candidate` (writes are never inserted in the middle, only removed,
+                //      so this condition will hold despite our delay)
+                //  b) `candidate` is not required for `call` to run
+                //  c) `call` replaces all values inside of `candidate`
+                // Which means, `candidate is entirely redunant, and can be removed!
+
+                if (Querysub.DEBUG_CALLS) {
+                    console.log(`[Querysub] ${magenta("removed redundant call")}      ${green(debugCallSpec(candidate.call))}    @${debugTime(candidate.call.runAtTime)}`);
+                }
+                callPending.splice(index2, 1);
+                // Cancel as well, in case it isn't redundant, so we can see the issue immediately.
+                candidate.cancel();
+
+                // Move our time back, otherwise repeated delays can result in not committing writes for
+                //  a long time (indefinitely really), which can result in a lot of lost work, and
+                //  has little speed benefit (comitting a write every 5 seconds is fine).
+                delayedCall.time = candidate.time;
+            }));
+
+            if (Querysub.DEBUG_CALLS) {
+                console.log(`[Querysub] ${magenta("delaying")}    ${green(debugCallSpec(call))}    @${debugTime(call.runAtTime)}`);
+            }
+            return;
+        }
+    }
+
+    await flushDelayedFunctions();
+    // NOTE: NO MORE calls can be queued here, because addCall is run in serial, so... we don't need
+    //  to worry about new calls with times > call.runAtTime (and if it happens we'll get a fairly
+    //  clear error clientside, which will show up in a notification, so it is a very safe assumption).
+    await baseAddCall(call, nodeId, cancel, "call");
+});
+
+function getPredictTime(time: Time) {
+    return { time: time.time, version: -2, creatorId: time.creatorId };
+}
+const predictionLockVersion = -2344282313;
+export function isOurPrediction(value: PathValue) {
+    return value.locks.length === 1 && value.locks[0].startTime.version === predictionLockVersion;
+}
+registerIsOurPrediction(isOurPrediction);
+
+interface PredictResult {
+    readPaths: Set<string>;
+    readParentPaths: Set<string>;
+    writes: PathValue[];
+    /** Writes that have been replaced AT the write time of the prediction */
+    replacedWriteValues: PathValue[];
+}
+function predictCall(config: {
+    call: CallSpec;
+    localOnly?: boolean;
+    overrides?: PathValue[];
+}): {
+    cancel: () => void;
+    predictPromise: Promise<PredictResult>;
+} {
+    let call = config.call;
+    let pathResultWrite = getCallResultPath(call);
+    Benchmark.onStartPredictCall(pathResultWrite);
+    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)
+        runCount: -1,
+        timeTaken: -1,
+        evalTime: 0,
+    };
+
+    // NOTE: We don't cascade predictions, instead only depending on the call succeeding. This is because if we depend on writes,
+    //  we will be invalidated before we get the actual call result, which results in going back in time, a delay, then
+    //  having the actual call results, and so jumping forward again. It is better to just wait, so our latest value
+    //  becomes the latest call value, when we receive it.
+    let predictResultWrite: PathValue = {
+        path: pathResultWrite,
+        value: functionResult,
+        locks: [
+            {
+                // We use a special version, so we don't have to worry about this actually existing. We don't really want
+                //  a lock on startTime, we just want the range lock.
+                startTime: { time: call.runAtTime.time, version: predictionLockVersion, creatorId: call.runAtTime.creatorId },
+                // NOTE: The version is special, and used to detect prediction rejections in some logging.
+                // NOTE: We need to set our end time enough in the future so errors cause us to be rejected
+                endTime: { time: call.runAtTime.time + MAX_CHANGE_AGE, version: Number.MAX_SAFE_INTEGER, creatorId: call.runAtTime.creatorId },
+                path: pathResultWrite,
+                // Technically we are depending on a future time, so... we are depending on ourself? And our value isn't undefined.
+                readIsTranparent: false,
+                keepRejectedUntil: call.runAtTime.time + CLIENTSIDE_PREDICT_LEEWAY
+            }
+        ],
+        lockCount: 1,
+        // We right our result BEFORE the actual result, so it will be clobbered (and before our read lock!)
+        //  when the result arrives (although... it will ALSO be rejected, so... this might be less important...)
+        //  (Also, more importantly, this ha to be UNIQUE, otherwise time locks break!)
+        time: getPredictTime(call.runAtTime),
+        valid: true,
+        event: true,
+    };
+    let predictLocks: ReadLock[] = [
+        {
+            startTime: predictResultWrite.time,
+            endTime: predictResultWrite.time,
+            path: pathResultWrite,
+            readIsTranparent: false,
+        }
+    ];
+    let predictions: PredictResult | undefined;
+    let predictPromise = predictRunCommitLoop(async () => {
+        if (Querysub.DEBUG_PREDICTIONS) {
+            console.log(magenta(`Start predict call`), `${call.DomainName}.${call.FunctionId}`);
+        }
+
+        if (!config.localOnly) {
+            // Watch the result, so we know when our prediction is rejected (which will be as soon as the result
+            //  has a real value).
+            remoteWatcher.watchLatest({ paths: [pathResultWrite], parentPaths: [] });
+        }
+        let debugName = `[predict]|${call.DomainName}.${call.FunctionId}`;
+
+        let dryRunResult: {
+            writes: PathValue[];
+            readPaths: Set<string>;
+            readParentPaths: Set<string>;
+        };
+        try {
+            dryRunResult = await getCallWrites({ call, debugName, overrides: config.overrides });
+        } catch (e) {
+
+            if (!pathValueSerializer.getPathValue(authorityStorage.getValueAtTime(pathResultWrite, undefined))) {
+                console.log(`Skipping prediction for ${debugName} due to error running predictive call. Likely just an out of order error.`, e);
+            } else {
+                // NOTE: This case happens a lot, because of how we handle locks. We don't receive locked values, and so
+                //  we assume all values have no locks, and only keep the latest. This is usually fine, but... if we lose
+                //  the race to predict the function against the server updating it, it is likely our prediction will now
+                //  be running before the latest write. In which case (as we don't really store write history), we will read undefined.
+                //  This isn't accurate, but... our write WILL almost certainly be wrong (as the value changed), so we don't log here.
+            }
+            return {
+                writes: [],
+                readPaths: new Set(),
+                readParentPaths: new Set(),
+                replacedWriteValues: [],
+            };
+        }
+        predictions = {
+            writes: dryRunResult.writes,
+            readPaths: dryRunResult.readPaths,
+            readParentPaths: dryRunResult.readParentPaths,
+            replacedWriteValues: dryRunResult.writes.map(write => {
+                let path = write.path;
+                let newWrite: PathValue = authorityStorage.getValueAtTime(write.path, write.time) || {
+                    path, valid: true, time: write.time, locks: [], lockCount: 0, value: undefined, canGCValue: true, isTransparent: true,
+                };
+                newWrite = { ...newWrite };
+                // Use a time very slightly after, so it clobbers the write, and any writes before it, but none after.
+                newWrite.time = write.time;
+                write.time = {
+                    time: write.time.time,
+                    version: write.time.version,
+                    creatorId: write.time.creatorId + 1,
+                };
+                return newWrite;
+            }),
+        };
+
+        for (let value of predictions.writes) {
+            value.source = debugName;
+        }
+
+        // If we already received the actual call, we can't add the prediction, as... the invalidation
+        //      code won't properly immediately reject our prediction, as we are not the authority on the
+        //      path, so it treats it as source of truth.
+        if (authorityStorage.getValueAtTime(pathResultWrite, undefined)?.value) {
+            if (Querysub.DEBUG_PREDICTIONS) {
+                console.log(magenta(`Abort predict call, already received call result`), `${call.DomainName}.${call.FunctionId}`);
+            }
+            return predictions;
+        }
+
+        // We commit slightly different writes, for  lock invalidation. Our caller doesn't need / doesn't want this
+        //  extra write, so we just don't return it.
+        // NOTE: I guess we technically don't need to actually write to the result, but... might as well?
+        predictions.writes.push(predictResultWrite);
+        // Update all locks to use the same locks as predictResultWrite
+        // Ensure we use the predict time, otherwise these times will be reused when the call actually happens,
+        //  potentially with different values, which breaks all of our ReadLocks!
+        for (let predict of predictions.writes) {
+            predict.time = predictResultWrite.time;
+            predict.locks = predictLocks;
+            predict.lockCount = predictLocks.length;
+        }
+
+        pathValueCommitter.ingestValues(predictions.writes, undefined, undefined);
+
+        // NOTE: We have to forcefully setup the lock watches, as we are no the authority on these paths
+        //  so it is odd for us to do this! It works out though, because the path is unique enough
+        //  that we don't have to worry about any other valid states coming in for our lock.
+        //  - Also, once we set up this lock, we should get full reject cascade support.
+        lockToCallback.watchLock(predictResultWrite.locks[0], [predictResultWrite]);
+        lockToCallback.watchLock(predictLocks[0], predictions.writes);
+
+        if (Querysub.DEBUG_PREDICTIONS) {
+            console.log(magenta(`Finished predict call`), `${call.DomainName}.${call.FunctionId}`);
+        }
+        return predictions;
+    });
+    logErrors(predictPromise);
+
+    let didCancel = false;
+    // ALWAYS reject the prediction eventually, in case the function runner server is down.
+    //  - ALSO, once it goes back up, the write will be too far in the future, and our lock won't be rejected.
+    //      And don't really want endTime to be infinitely in the future, as then cleanup code has a harder time
+    //      removing the lock, as then in theory it can always be rejected, no matter how long we wait.
+    setTimeout(rejectPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
+    function rejectPrediction() {
+        if (didCancel) return;
+        didCancel = true;
+        // Reject our predictions, as the call likely never got committed, so it will never be written
+        pathValueCommitter.ingestValidStates([{
+            path: pathResultWrite,
+            isValid: false,
+            time: predictResultWrite.locks[0].startTime,
+            isTransparent: false,
+        }]);
+    }
+    setTimeout(auditPrediction, Querysub.PREDICTION_MAX_LIFESPAN);
+    function auditPrediction() {
+        if (didCancel) return;
+        if (Querysub.AUDIT_PREDICTIONS && predictions) {
+            const afterTime = { time: call.runAtTime.time, version: Number.MAX_SAFE_INTEGER, creatorId: 0 };
+            // Clone predictions, to strip symbols
+            let predictionsCopy = cborEncoder().decode(cborEncoder().encode(predictions)) as typeof predictions;
+            for (let predict of predictionsCopy.writes ?? []) {
+                if (predict.path === pathResultWrite) continue;
+                let finalValueObj = authorityStorage.getValueAtTime(predict.path, afterTime);
+                if (!authorityStorage.isSynced(predict.path)) continue;
+
+                let finalValue = pathValueSerializer.getPathValue(finalValueObj);
+                let predictValue = pathValueSerializer.getPathValue(predict);
+
+                let finalBuffer = cborEncoder().encode(finalValue);
+                let predictBuffer = cborEncoder().encode(predictValue);
+                // If they are different, warn
+                if (!finalBuffer.equals(predictBuffer)) {
+                    // NOTE: This MIGHT be due to delayCommit on another function. We can't know when to force flush
+                    //  delayCommit values, and so we only force flush if other (non-delayCommit) functions are committed
+                    //  in the same schema, which will be wrong if data is accessed cross schema.
+                    //  - If this happens, and is a problem, we COULD handle it, but... it is very difficult, as we would need
+                    //      to evaluate the other function, detect it conflicts with a delayCommit functions, then run the delayCommit
+                    //      function, then re-evaluated the conflicted prediction (which is a lot of communication and reruns
+                    //      between a lot of systems... especially because in a second this will resolve by the server
+                    //      clobbering our prediction).
+                    //      - AND, we can't commit the pending calls until we sort out the order, so this necessarily requires
+                    //          slowing down commits if we are delaying other calls.
+                    console.warn(`${red("Prediction was wrong")}: ${getPathFromStr(predict.path).join(".")} predict != finalValue`, predictValue, finalValue);
+                }
+            }
+        }
+    }
+
+    return {
+        cancel: rejectPrediction,
+        predictPromise,
+    };
+}
+
+export async function getCallWrites(config: {
+    debugName: string;
+    call: CallSpec;
+    overrides?: PathValue[];
+}) {
+    let { call, debugName } = config;
+    let { functionSpec } = await proxyWatcher.commitFunction({
+        watchFunction: function getModuleConfig() {
+            //let moduleConfig = atomicObjectRead(functionSchema()[call.DomainName].PathFunctionRunner[call.ModuleId].Module);
+            // if (!(call.DomainName in functionSchema())) {
+            //     throw new Error(`Domain not found ${call.DomainName}`);
+            // }
+            let domainObject = functionSchema()[call.DomainName];
+            if (!(call.ModuleId in domainObject.PathFunctionRunner)) {
+                throw new Error(`Module not found ${call.DomainName}.${call.ModuleId}`);
+            }
+            let moduleObject = domainObject.PathFunctionRunner[call.ModuleId];
+            if (!(call.FunctionId in moduleObject.Sources)) {
+                throw new Error(`Function not found ${call.DomainName}.${call.ModuleId}.${call.FunctionId}`);
+            }
+            let functionSpec = atomicObjectRead(moduleObject.Sources[call.FunctionId]);
+            return { functionSpec };
+        }
+    });
+    if (!functionSpec) {
+        throw new Error(`Function not found ${call.DomainName}.${call.ModuleId}.${call.FunctionId}`);
+    }
+
+    await addModuleToLoader(functionSpec);
+
+    let module = await getModuleFromConfig(functionSpec);
+    let exportPath = getPathFromStr(functionSpec.exportPathStr);
+    let exportObj = module.exports;
+    for (let path of exportPath) {
+        exportObj = exportObj[path];
+    }
+    let baseFunction = exportObj as Function;
+
+    return await proxyWatcher.dryRunFull({
+        debugName,
+        runAtTime: call.runAtTime,
+        overrideAllowLockDomainsPrefixes: [getPathStr1(call.DomainName)],
+        // We are going to clobber locks anyways, so there is no reason to create them
+        unsafeNoLocks: true,
+        overrides: config.overrides,
+        nestedCalls: "inline",
+        watchFunction() {
+            overrideCurrentCall(call, () => {
+                let args = parseArgs(call);
+                baseFunction(...args);
+            });
+        },
+    });
+}

package/src/5-diagnostics/FullscreenModal.tsx

@@ -0,0 +1,67 @@
+import preact from "preact";
+import { qreact } from "../4-dom/qreact";
+import { Button } from "../library-components/Button";
+import { Modal } from "./Modal";
+
+
+export class FullscreenModal extends preact.Component<{
+    parentState?: { open: boolean };
+    onCancel?: () => void;
+    style?: preact.JSX.CSSProperties;
+    outerStyle?: preact.JSX.CSSProperties;
+}> {
+    render() {
+        let { parentState } = this.props;
+        return (
+            <Modal>
+                <div style={{ display: "none" }}>
+                    <Button hotkeys={["Global+Escape"]} onClick={() => {
+                        if (parentState) parentState.open = false;
+                        this.props.onCancel?.();
+                    }}>Close</Button>
+                </div>
+                <div
+                    style={{
+                        position: "fixed",
+                        top: 0,
+                        left: 0,
+                        width: "100vw",
+                        height: "100vh",
+                        background: "hsla(0, 0%, 30%, 0.5)",
+                        padding: 100,
+                        display: "flex",
+                        alignItems: "center",
+                        justifyContent: "center",
+                        overflow: "auto",
+                        cursor: "pointer",
+                        ...this.props.outerStyle,
+                    }}
+                    onClick={e => {
+                        if (qreact.isTarget(e)) {
+                            if (parentState) parentState.open = false;
+                            this.props.onCancel?.();
+                        }
+                    }}
+                >
+                    <div
+                        style={{
+                            background: "hsl(0, 0%, 100%)",
+                            padding: 20,
+                            color: "hsl(0, 0%, 7%)",
+                            cursor: "default",
+                            width: "100%",
+                            display: "flex",
+                            flexDirection: "column",
+                            gap: 10,
+                            maxHeight: "calc(100% - 200px)",
+                            overflow: "auto",
+                            ...this.props.style
+                        }}
+                    >
+                        {this.props.children}
+                    </div>
+                </div>
+            </Modal>
+        );
+    }
+}