querysub 0.403.0 → 0.405.0

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

@@ -1,522 +1,597 @@
-import fs from "fs";
-import { cache, lazy } from "socket-function/src/caching";
-import { getStringKeys, sort } from "socket-function/src/misc";
-import { Args } from "socket-function/src/types";
-import { appendToPathStr, getPathFromStr, getPathStr, rootPathStr } from "../path";
-import { writeFunctionCall } from "./PathFunctionHelpers";
-import { CallSpec, functionSchema } from "./PathFunctionRunner";
-import { getDomain, isLocal } from "../config";
-import { isHotReloading } from "socket-function/hot/HotReloadController";
-import { Schema2, Schema2Fncs, Schema2T, SchemaPath } from "../2-proxy/schema2";
-import { PathValueProxyWatcher, atomic, proxyWatcher, registerSchema } from "../2-proxy/PathValueProxyWatcher";
-import { registerAliveChecker } from "../2-proxy/garbageCollection";
-import { rawSchema } from "../2-proxy/pathDatabaseProxyBase";
-import { ARCHIVE_FLUSH_LIMIT } from "../0-path-value-core/pathValueCore";
-import debugbreak from "debugbreak";
-import { getPathFromProxy, getProxyPath } from "../2-proxy/pathValueProxy";
-import { CALL_PERMISSIONS_KEY } from "../4-querysub/permissionsShared";
-import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
-import path from "path";
-import { isEmpty } from "../misc";
-import { getSpecFromModule } from "./pathFunctionLoader";
-import { isNode } from "typesafecss";
-import { Querysub } from "../4-querysub/QuerysubController";
-
-// This is the the function id which should be used when creating the FunctionSpec (in order to load the module),
-//  to access the permissions in the schema.
-export const PERMISSIONS_FUNCTION_ID = "PERMISSIONS_FUNCTION_ID";
-
-const SCHEMA_EXPORT_KEY = "schema-00c87ab5-10bb-4795-8f6b-e187a7e45841";
-export function getSchemaObject(module: NodeJS.Module): SchemaObject | undefined {
-    return module.exports[SCHEMA_EXPORT_KEY];
-}
-
-export function getExportPath(functionId: string): string {
-    return getPathStr([SCHEMA_EXPORT_KEY, "rawFunctions", functionId]);
-}
-
-export type FunctionMetadata<F = unknown> = {
-    nopredict?: boolean;
-    /** Removes unnecessary function calls by first delaying by Querysub.DELAY_COMMIT_DELAY, Then looking at their predictions and removing ones where their predictions completely clobber the other ones.
-     *      - Determines unnecessary calls via our function prediction. If our function is prediction is wrong, we might remove calls that shouldn't be removed. 
-     *      - This is quite dangerous, but extremely useful for things such as editors when you want to type and have things update quickly, but you don't want to spam the server with calls. 
-     *      - Only applied for clients.
-     *      - We will always preserve the order of function calls in the same schema, so if you make another function call that doesn't have delay commit in the same schema, then we will forcefully commit all the delayed commit functions first.
-     *          - This shouldn't cause an excessive amount of function commits. The delayed commit time is very small, maybe around five seconds. And if you are regularly having commits that are faster than that, that aren't delayed commit, then you're already having a lot of commits. And we will still remove unnecessary calls, even if we have to commit them earlier than the delay. 
-     *      - IMPORTANT! Our check for if values should be removed isn't perfect. If you write to a path that another value reads from, and then it writes that value to a path that we then read from... This would mean our value can't be clobbered as it has side effects which would affect values that could regularly clobber us. However, we don't detect this case, and we will just allow it to be clobbered.
-     *          - However, when we clobber values, we will cancel them client-side fairly quickly, so it should be apparent if this bug happens, in which case the writes you're doing are too complicated and you shouldn't be using delay commit. Delay commit is only really intended for simple cases, such as the user presses a key and then you set some text equal to a result based on that key (It doesn't work with deltas, You need to be forcefully setting the value). 
-     */
-    delayCommit?: boolean;
-
-    /** By default, we try to finish calls in the start order when using Querysub.commitAsync, unless the caller explicitly says not to. However, if this is set, then we won't have this call finish or cause other calls to be finished in the start order. This makes locking less safe, but can be useful for long-running functions that shouldn't block other functions and which the order doesn't matter. */
-    noFinishInStartOrder?: boolean;
-
-    /** Too many locks can lag the server, and eventually cause crashes. Consider using Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. However, if absolutely required, you can override max locks to allow as many locks to be created as you want until the server crashses... */
-    maxLocksOverride?: number;
-};
-
-export interface SchemaObject<Schema = any, Functions = any> {
-    data: () => Schema;
-    domainName: string;
-    moduleId: string;
-    functions: {
-        [key in keyof Functions]: (
-            //Functions[key] &
-            // NOTE: Functions don't have results, if you want a result write to the database
-            //  and then watch it for the result.
-            //  - The promise resolves once the function has started the commit process, NOT when
-            //      it has finished. Once it resolves you can terminate your process and the function
-            //      will run (but it might still error out due to taking too long to reach the server,
-            //      or too long to run, or insufficient privileges, etc, etc).
-            ((...args: Args<Functions[key]>) => CallSpec) & {
-                // Add a "debugger;" when the holding function is called, to make it easy to debug the function
-                debug(): void;
-            }
-        )
-    };
-    functionMetadata: {
-        [key in keyof Functions]?: FunctionMetadata<Functions[key]> | undefined;
-    };
-    rawFunctions: Functions;
-    permissions: SchemaToPermissions<Schema> | undefined;
-    permissionsNonWildcards: Map<string, PermissionsCallback>;
-    // Sorted by most nested first
-    permissionsWildcards: {
-        pathParts: string[];
-        callback: PermissionsCallback;
-    }[];
-}
-
-let existsCached = cache((path: string) => {
-    return fs.existsSync(path);
-});
-
-
-export function getModuleRelativePath(module: NodeJS.Module): string {
-    let root = path.resolve(".").replaceAll("\\", "/");
-    if (!existsCached(root + "/package.json")) {
-        throw new Error(`Expected to find package.json at ${root}. The current directory must be the root of the project when deploying, so we can resolve relative file references.`);
-    }
-    // Get the relative path
-    let relativePath = path.relative(root, module.filename).replaceAll("\\", "/");
-    if (relativePath.startsWith("../")) {
-        let otherFolder = relativePath.split("/")[1];
-        if (existsCached("node_modules/" + otherFolder)) {
-            relativePath = "node_modules/" + otherFolder + "/" + relativePath.split("/").slice(2).join("/");
-        }
-    }
-    return "/" + relativePath;
-}
-
-export type PermissionsParameters = {
-    // Each part of the path that matched with a wildcard ("*") is added to this array (in order).
-    pathWildcards: string[];
-    /**
-     *  The path the permissions check matched.
-     *      NOTE: The full path matched is not provided for optimization purposes. Otherwise for large
-     *          writes the permissions check would be needlessly run. IF further depth is required,
-     *          use "*" wildcards. If the depth is dynamic... your structure is probably too complex,
-     *          or something similar to a tree. Destructure it to a list, and all of your
-     *          code will run significantly faster.
-     * 
-     *          TODO: If we ABSOLUTELY need it, we COULD conditionally expose fullPath, and just disable
-     *              optimizations when we do. We could even have a parameter which replaces matchedPath with
-     *              fullPath. But, ideally we don't, as it is just very inefficient...
-     *      NOTE: Usually pathWildcards should be used instead. This is only useful if you want to create
-     *          a very generic permission check which can be used in many hierarchies, and depends on the
-     *          hierarchy (ex, if it checks path.slice(0, 3).users for the users table).
-     **/
-    matchedPath: string;
-    /** The callerMachineId will be unique to the calling machine (but a machine may have multiple,
-            ex, 1 per browser, another a fresh one if they are in incognito mode).
-            - To tie machineIds to userIds simple create a lookup in your database, for example:
-                    `{ machineToUserId: { [machineId: string]: string | undefined } }`
-                Logging out from a machine is simply:
-                    `machineToUserId[machineId] = undefined`
-                A reverse index may also be useful, to efficiently log out everywhere (or just
-                    show all machines that a user is logged into)
-                ```
-                    { userIdToMachineIds: { [userId: string]: { [machineId: string]: 1 } } }
-                   funcion logoutEverywhere(userId: string) {
-                        for (let machineId in userIdToMachineIds[userId]) {
-                            userIdToMachineIds[userId][machineId] = undefined;
-                            machineToUserId[machineId] = undefined;
-                        }
-                    }
-                ```
-     * */
-    callerMachineId: string;
-
-    // IMPORTANT! DO NOT add "matchedValue" here. It is convenient, BUT, it is better for the user
-    //  to access it themselves using pathWildcards. This makes it more typesafe, allowing
-    //  them to find all references and find that reference (otherwise the reference will be hidden).
-    //  - Also, I don't think we could make matchedValue typesafe at all, so it would have to be any,
-    //      which is terrible.
-};
-/** A false of false will deny read permissions, resulting in all reads being given value with a value
- *      of undefined, and a time of 0.
- 
- */
-export type PermissionsCallback = (config: PermissionsParameters) => PermissionsCheckResult;
-export type PermissionsCheckResult = boolean | { allowed: boolean; skipParentChecks?: boolean; };
-/*
-    NOTE: All ancestor permissions checks are applied as well.
-        - This means if the ancestor disallows, it blocks any descendant checks even if they are allowed.
-
-    NOTE: If no permissions match, then access is disallowed by default.
-
-    NOTE: Permissions checks at the root (permissions: { READ_PERMISSIONS(config) { } }) will
-        be used to verify calls are allowed as well, even if the call doesn't read or write any data
-        that is under a permissions check.
-        - THIS MEANS that if there is no permission check at the root, calls won't be allowed by any user
-            (as we default to disallow).
-
-    NOTE: Servers watches ignore permissions, as they directly communicate with the underlying PathValueServer,
-        skipping the ProxyServer.
-        - However function calls by servers are still run by FunctionRunner, which will apply permission checks.
-
-    IMPORTANT! Wildcards are tested via the "" path. This means if the "" key is provided access to a user, they can run
-        Object.keys()/Object.values() on the data. In order to not accidentally provide list access, never allow "" to be
-        a valid path, by never providing access by exclusion. For example:
-            BROKEN: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] !== "admin" || users()[config.callerId].isAdmin; } } }`
-                - This will allow users to access the "admin" data via Object.values(), because the "" !== "admin"
-            BROKEN: `{ admin: { PERMISSIONS(){ return users()[config.callerId].isAdmin; } } }`
-                - Because "" isn't checked
-            CORRECT: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] === config.callerId; } } }`
-            CORRECT: `{ ["*"]: { PERMISSIONS(){ return users()[config.callerId].isAdmin || config.pathWildcards?.[0] === config.callerId; } } }`
-
-    NOTE: Permission checks lag a bit behind data. This means not only will a write that removes checks of itself
-        still be sent (ex, if a user removes their admin access, and only admins can see who is an admin or not,
-        they will be told about their admin change). BUT, a user will receive writes for a bit after that as well!
-        The delay is equal to the network propagation time between two server, which is small (ideally milliseconds),
-        but in the case of excess lag could easily be 10s of seconds (in which case everything on the site would
-        be lagging by 10s of seconds as well).
-
-    For example
-        permissions: {
-            userSecretData: {
-                ["*"]: {
-                    PERMISSIONS(pathWildcards) {
-                        return config.pathWildcards[0] === config.callerMachineId;
-                    }
-                }
-            }
-        }
-*/
-export type SchemaToPermissions<Schema> = {
-    [key in keyof Schema]?: SchemaToPermissions<Schema[key]>;
-} & {
-    PERMISSIONS?: PermissionsCallback;
-} | {
-    PERMISSIONS?: PermissionsCallback;
-};
-
-/** A special key which is prefixed (along with a random value) before special keys used to check child
- *      permissions. This allows us to explicitly disallow parent syncing (ex Object.keys()) of values.
- */
-export const CHILD_CHECK_PREFIX = "";
-
-export function hasWildcardMatch(permissionsPath: string[], valuePathParts: string[]): boolean {
-    for (let i = 0; i < permissionsPath.length; i++) {
-        let part = permissionsPath[i];
-        if (part === "*") {
-
-        } else if (part !== valuePathParts[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-export function getWildcardMatches(permissionsPath: string[], valuePathParts: string[]): string[] | undefined {
-    if (permissionsPath.length > valuePathParts.length) return undefined;
-    let wildcardMatches: string[] | undefined;
-    for (let i = 0; i < permissionsPath.length; i++) {
-        let part = permissionsPath[i];
-        if (part === "*") {
-            if (!wildcardMatches) wildcardMatches = [];
-            wildcardMatches.push(valuePathParts[i]);
-        } else if (part !== valuePathParts[i]) {
-            return undefined;
-        }
-    }
-    return wildcardMatches;
-}
-
-let inliningCalls = false;
-export function inlineNestedCalls<T>(code: () => T) {
-    let prev = inliningCalls;
-    inliningCalls = true;
-    try {
-        return code();
-    } finally {
-        inliningCalls = prev;
-    }
-}
-
-type SyncSchemaResult<Schema> = {
-    // NOTE: The functions are over the network, AND, eventually consistent, so it is not possible
-    //  for them to return a result. If a result is required, pass an id which will instruct them where
-    //  to write their result to, and then watch that location.
-    <Functions extends { [name: string]: ((...args: any) => void) }>(config: {
-        domainName?: string;
-        /** NOTE: moduleId is used to store your data in a unique location, that doesn't change
-         *      if you move this file around. Any unique identifier is allowed, as the deploy command
-         *      will warn you if you accidentally reused a moduleId.
-         */
-        moduleId: string;
-        module: NodeJS.Module;
-        functions: Functions;
-        functionMetadata?: { [name in keyof Functions]?: FunctionMetadata<Functions[name]> };
-        /** Provide access to [Querysub.CALL_PERMISSIONS_KEY] to allow function calls (or provide access at the root). */
-        permissions?: SchemaToPermissions<Schema> & {
-            [CALL_PERMISSIONS_KEY]?: {
-                PERMISSIONS: PermissionsCallback;
-            };
-        };
-    }): SchemaObject<Schema, Functions>;
-};
-
-export function syncSchema<Schema>(): SyncSchemaResult<Schema>;
-export function syncSchema<SchemaDef extends Schema2>(schema: SchemaDef): SyncSchemaResult<Schema2T<SchemaDef>>;
-export function syncSchema<Schema>(schema?: Schema2): SyncSchemaResult<Schema> {
-    return function getFunctions(config) {
-        const { moduleId, functions, module, permissions } = config;
-        const domainName = config.domainName ?? getDomain();
-
-        const data = () => functionSchema()[domainName].PathFunctionRunner[moduleId].Data;
-
-        let fncs = { ...functions };
-
-        let undoChecksAdded: {
-            name: string;
-            path: SchemaPath;
-        }[] = [];
-        if (schema) {
-            let dataPrefixPath = getPathFromStr(getProxyPath(data));
-            let fnc = getSpecFromModule(module);
-            // NOTE: We call syncSchema a lot, so we default the git hash. However, for modules that provide
-            //  functions we call as synced functions, we SHOULD have a real hash here.
-            let gitHash = fnc?.gitRef || "ambient";
-            registerSchema({ domainName, moduleId, schema, gitHash });
-
-            let gcDefs = Schema2Fncs.getGCObjects(schema);
-            for (let { path, gcDelay } of gcDefs) {
-                createObjectAliveChecker(data, path, gcDelay);
-            }
-
-            let undoChecks = Schema2Fncs.getAllUndoChecks(schema);
-            for (let checkObj of undoChecks) {
-                // Need at least one check
-                if (checkObj.undoChecks.length === 0) continue;
-                function niceSchemaPath(path: SchemaPath) {
-                    return path.map(x => x === Schema2Fncs.WildCard ? "*" : x).join(".");
-                }
-                let name = `__undoer__${niceSchemaPath(checkObj.path)}`;
-                let fullPath = (dataPrefixPath as SchemaPath).concat(checkObj.path);
-                undoChecksAdded.push({
-                    name,
-                    path: fullPath,
-                });
-                (fncs as any)[name] = function undoCallback(path: string[], value: unknown) {
-                    if (!isChildPath(fullPath, path)) {
-                        throw new Error(`Tried to access undo function with path not under undo spec ${niceSchemaPath(fullPath)} . Tried to use path ${path.join(".")}`);
-                    }
-
-                    let permissionsChecker = proxyWatcher.getTriggeredWatcher().permissionsChecker;
-                    if (permissionsChecker) {
-                        let permissionsCheck = permissionsChecker.checkPermissions(getPathStr(path));
-                        if (!permissionsCheck?.allowed) {
-                            throw new Error(`Failed read permission check for undo call at path ${path.join(".")}`);
-                        }
-                    }
-                    for (let check of checkObj.undoChecks) {
-                        let nestedPath = path.slice(0, fullPath.length);
-                        let key = nestedPath[nestedPath.length - 1];
-                        if (!atomic(check(key, nestedPath))) {
-                            throw new Error(`Failed undo permission check at path ${nestedPath.join(".")}, check ${check.name || check.toString().slice(0, 100)}`);
-                        }
-                    }
-                    let parent = rawSchema()() as any;
-                    for (let i = 0; i < path.length - 1; i++) {
-                        parent = parent[path[i]];
-                    }
-                    let key = path[path.length - 1];
-
-                    // NOTE: This isn't an atomic set, because we leave it up proxyWatcher (and schema2)
-                    //  to correctly handle assigning the values atomically.
-                    parent[key] = value;
-                };
-            }
-        }
-
-        let wrappedFunctions: { [name: string]: (...args: any) => CallSpec } = Object.create(null);
-        let functionMetadata = config.functionMetadata;
-        for (let [name, fnc] of Object.entries(fncs)) {
-            let metadata = functionMetadata?.[name] ?? {};
-            let debugging = false;
-            wrappedFunctions[name] = Object.assign((...args: any[]): any => {
-                if (inliningCalls) {
-                    return fnc(...args);
-                }
-                if (debugging) {
-                    debugger;
-                }
-                return writeFunctionCall({
-                    domainName,
-                    moduleId,
-                    functionId: name,
-                    args,
-                    metadata: metadata
-                });
-            }, {
-                debug() {
-                    debugging = true;
-                }
-            });
-        }
-
-        for (let check of undoChecksAdded) {
-            registeredUndoChecks.push({
-                path: check.path,
-                undoSet: wrappedFunctions[check.name] as any,
-            });
-        }
-
-        let permissionsNonWildcards = new Map<string, PermissionsCallback>();
-        let permissionsWildcards: { pathParts: string[]; callback: PermissionsCallback }[] = [];
-        addPermissions(rootPathStr, permissions);
-        function addPermissions(path: string, permissions: SchemaToPermissions<Schema> | undefined) {
-            if (!permissions) return;
-            for (let key of getStringKeys(permissions)) {
-                if (key === "PERMISSIONS") {
-                    let value = permissions.PERMISSIONS;
-                    if (value) {
-                        if (path.includes("*")) {
-                            permissionsWildcards.push({
-                                pathParts: getPathFromStr(path),
-                                callback: value,
-                            });
-                        } else {
-                            permissionsNonWildcards.set(path, value);
-                        }
-                    }
-                } else {
-                    addPermissions(appendToPathStr(path, key), permissions[key]);
-                }
-            }
-        }
-        // Sort reversed, so the most specific checks are first
-        permissionsWildcards.sort((b, a) => a.pathParts.length - b.pathParts.length);
-
-        // NOTE: We cache the root with lazy, to save time evaluating each proxy on each access. Also, it reduces the extra paths accesses that will never have data.
-        //  - Permissions should be fine, as we check them directly (if the user wants a path we check it), so we don't throw on accessing the root data and then allow all child accesses (each path is checked independently).
-        let dataCached = lazy(() => data());
-        let result: SchemaObject = {
-            data: dataCached,
-            domainName,
-            moduleId,
-            functions: wrappedFunctions as any,
-            functionMetadata: functionMetadata as any,
-            rawFunctions: fncs,
-            permissions,
-            permissionsNonWildcards,
-            permissionsWildcards,
-        };
-
-        if (!isHotReloading() && module.exports[SCHEMA_EXPORT_KEY]) {
-            throw new Error(`Module ${moduleId} already has a schema. Only 1 schema is allowed per module.`);
-        }
-
-        // NOTE: We clobber the previous value, as we might just be hotreloading, which
-        //  could mean the exports value has our previous value.
-        module.exports[SCHEMA_EXPORT_KEY] = result;
-        developmentModules.set(moduleId, module);
-        return result;
-    };
-}
-let developmentModules = new Map<string, NodeJS.Module>();
-
-export function getDevelopmentModule(moduleId: string): NodeJS.Module | undefined {
-    return developmentModules.get(moduleId);
-}
-export function getAllDevelopmentModulesIds(): string[] {
-    return Array.from(developmentModules.keys());
-}
-
-function isChildPath(spec: SchemaPath, path: string[]): boolean {
-    if (spec.length > path.length) return false;
-    for (let i = 0; i < spec.length; i++) {
-        if (spec[i] === Schema2Fncs.WildCard) continue;
-        if (spec[i] !== path[i]) return false;
-    }
-    return true;
-}
-
-// pathStr => ...
-let registeredUndoChecks: {
-    path: SchemaPath;
-    undoSet: (nestedPath: string[], value: unknown) => void;
-}[] = [];
-
-export function registerUndoCallback(path: SchemaPath, undoSet: (nestedPath: string[], value: unknown) => void) {
-    registeredUndoChecks.push({ path, undoSet });
-}
-
-/** Throws if there is no undo callback available at this path. */
-export function getUndoCallback(path: string[]): {
-    setValue(path: string[], value: unknown): void;
-} {
-    // Local undos are always allowed
-    if (path[0] === LOCAL_DOMAIN) {
-        return {
-            setValue(path, value) {
-                if (path[0] !== LOCAL_DOMAIN) throw new Error(`Cannot set non-local value with local undo function. Tried to use path ${path.join(".")}`);
-                let parent = rawSchema()() as any;
-                for (let i = 0; i < path.length - 1; i++) {
-                    parent = parent[path[i]];
-                }
-                let key = path[path.length - 1];
-                parent[key] = value;
-            }
-        };
-    }
-    // Any callback should be fine?
-    let undoCallbacks = registeredUndoChecks.filter(x => isChildPath(x.path, path));
-    sort(undoCallbacks, x => -x.path.length);
-    if (undoCallbacks.length === 0) {
-        throw new Error(`No undo callback available at path ${path.join(".")}. There needs to be an undo region at or above this path, via t.undoRegion`);
-    }
-    return { setValue: undoCallbacks[0].undoSet };
-}
-
-function createObjectAliveChecker(data: () => any, path: SchemaPath, delay: number | undefined) {
-    registerAliveChecker({
-        object(wildcard) {
-            let obj = data();
-            for (let part of path) {
-                if (part === Schema2Fncs.WildCard) {
-                    obj = obj[wildcard];
-                } else {
-                    obj = obj[part];
-                }
-            }
-            return obj;
-        },
-        isAlive(value, path) {
-            let parent = rawSchema()() as any;
-            for (let i = 0; i < path.length - 1; i++) {
-                parent = parent[path[i]];
-            }
-            let key = path[path.length - 1];
-            let isAlive = key in parent;
-            return isAlive;
-        },
-        deleteDelayTime: delay,
-        // NOTE: This is actually safe, as we only read a single value, and are really
-        //  just looking to see if ANYTHING has created the value. Without this there is
-        //  a large gap when the value could be deleted, then undeleted, and then
-        //  as we only read old values we might not see the undelete. WITH this the gap
-        //  is much smaller (but still there).
-        unsafeLiveReads: true,
-    });
+import fs from "fs";
+import { cache, lazy } from "socket-function/src/caching";
+import { getStringKeys, sort } from "socket-function/src/misc";
+import { Args } from "socket-function/src/types";
+import { appendToPathStr, getPathFromStr, getPathStr, joinPathStres, rootPathStr } from "../path";
+import { writeFunctionCall } from "./PathFunctionHelpers";
+import { CallSpec, functionSchema } from "./PathFunctionRunner";
+import { getDomain, isLocal } from "../config";
+import { isHotReloading } from "socket-function/hot/HotReloadController";
+import { Schema2, Schema2Fncs, Schema2T, SchemaPath } from "../2-proxy/schema2";
+import { PathValueProxyWatcher, atomic, proxyWatcher, registerSchema } from "../2-proxy/PathValueProxyWatcher";
+import { registerAliveChecker } from "../2-proxy/garbageCollection";
+import { rawSchema } from "../2-proxy/pathDatabaseProxyBase";
+import { ARCHIVE_FLUSH_LIMIT } from "../0-path-value-core/pathValueCore";
+import debugbreak from "debugbreak";
+import { getPathFromProxy, getProxyPath } from "../2-proxy/pathValueProxy";
+import type { CALL_PERMISSIONS_KEY } from "../4-querysub/permissionsShared";
+import path from "path";
+import { isEmpty } from "../misc";
+import { getSpecFromModule } from "./pathFunctionLoader";
+import { isNode } from "typesafecss";
+import { LOCAL_DOMAIN } from "../0-path-value-core/PathRouter";
+import { createRoutingOverrideKey } from "../0-path-value-core/PathRouterRouteOverride";
+
+// This is the the function id which should be used when creating the FunctionSpec (in order to load the module),
+//  to access the permissions in the schema.
+export const PERMISSIONS_FUNCTION_ID = "PERMISSIONS_FUNCTION_ID";
+
+const SCHEMA_EXPORT_KEY = "schema-00c87ab5-10bb-4795-8f6b-e187a7e45841";
+export function getSchemaObject(module: NodeJS.Module): SchemaObject | undefined {
+    return module.exports[SCHEMA_EXPORT_KEY];
+}
+
+export function getExportPath(functionId: string): string {
+    return getPathStr([SCHEMA_EXPORT_KEY, "rawFunctions", functionId]);
+}
+
+export type FunctionMetadata<Schema = unknown, F = unknown> = {
+    nopredict?: boolean;
+    /** Removes unnecessary function calls by first delaying by Querysub.DELAY_COMMIT_DELAY, Then looking at their predictions and removing ones where their predictions completely clobber the other ones.
+     *      - Determines unnecessary calls via our function prediction. If our function is prediction is wrong, we might remove calls that shouldn't be removed. 
+     *      - This is quite dangerous, but extremely useful for things such as editors when you want to type and have things update quickly, but you don't want to spam the server with calls. 
+     *      - Only applied for clients.
+     *      - We will always preserve the order of function calls in the same schema, so if you make another function call that doesn't have delay commit in the same schema, then we will forcefully commit all the delayed commit functions first.
+     *          - This shouldn't cause an excessive amount of function commits. The delayed commit time is very small, maybe around five seconds. And if you are regularly having commits that are faster than that, that aren't delayed commit, then you're already having a lot of commits. And we will still remove unnecessary calls, even if we have to commit them earlier than the delay. 
+     *      - IMPORTANT! Our check for if values should be removed isn't perfect. If you write to a path that another value reads from, and then it writes that value to a path that we then read from... This would mean our value can't be clobbered as it has side effects which would affect values that could regularly clobber us. However, we don't detect this case, and we will just allow it to be clobbered.
+     *          - However, when we clobber values, we will cancel them client-side fairly quickly, so it should be apparent if this bug happens, in which case the writes you're doing are too complicated and you shouldn't be using delay commit. Delay commit is only really intended for simple cases, such as the user presses a key and then you set some text equal to a result based on that key (It doesn't work with deltas, You need to be forcefully setting the value). 
+     */
+    delayCommit?: boolean;
+
+    /** By default, we try to finish calls in the start order when using Querysub.commitAsync, unless the caller explicitly says not to. However, if this is set, then we won't have this call finish or cause other calls to be finished in the start order. This makes locking less safe, but can be useful for long-running functions that shouldn't block other functions and which the order doesn't matter. */
+    noFinishInStartOrder?: boolean;
+
+    /** Too many locks can lag the server, and eventually cause crashes. Consider using Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. However, if absolutely required, you can override max locks to allow as many locks to be created as you want until the server crashses... */
+    maxLocksOverride?: number;
+
+    // NOTE: Eventually we might want to support dynamic paths per call, so we can supported nested lookups.
+    //  - We also need to support specifying on the lookup that the key is in the nested lookup, which means hashing has to support wildcards, etc. All-in-all the whole change is very complicated, and only needed for hypothetical cases (data().worlds[region][id]...), which could probably be flattened anyways to just a single lookup (data().worlds[region + "-" + id]...)
+    /** This should identify the most common lookup accessed, and then give the path to that lookup and the key that we're using to access it. */
+    keyOverride?: {
+        getPrefix: (data: () => Schema) => unknown;
+        getKey: (...args: Args<F>) => string;
+    };
+};
+
+export interface SchemaObject<Schema = any, Functions = any> {
+    data: () => Schema;
+    domainName: string;
+    moduleId: string;
+    functions: {
+        [key in keyof Functions]: (
+            //Functions[key] &
+            // NOTE: Functions don't have results, if you want a result write to the database
+            //  and then watch it for the result.
+            //  - The promise resolves once the function has started the commit process, NOT when
+            //      it has finished. Once it resolves you can terminate your process and the function
+            //      will run (but it might still error out due to taking too long to reach the server,
+            //      or too long to run, or insufficient privileges, etc, etc).
+            ((...args: Args<Functions[key]>) => CallSpec) & {
+                // Add a "debugger;" when the holding function is called, to make it easy to debug the function
+                debug(): void;
+            }
+        )
+    };
+    functionMetadata: {
+        [key in keyof Functions]?: FunctionMetadata<Schema, Functions[key]> | undefined;
+    };
+    rawFunctions: Functions;
+    permissions: SchemaToPermissions<Schema> | undefined;
+    permissionsNonWildcards: Map<string, PermissionsCallback>;
+    // Sorted by most nested first
+    permissionsWildcards: {
+        pathParts: string[];
+        callback: PermissionsCallback;
+    }[];
+}
+
+let existsCached = cache((path: string) => {
+    return fs.existsSync(path);
+});
+
+
+export function getModuleRelativePath(module: NodeJS.Module): string {
+    let root = path.resolve(".").replaceAll("\\", "/");
+    if (!existsCached(root + "/package.json")) {
+        throw new Error(`Expected to find package.json at ${root}. The current directory must be the root of the project when deploying, so we can resolve relative file references.`);
+    }
+    // Get the relative path
+    let relativePath = path.relative(root, module.filename).replaceAll("\\", "/");
+    if (relativePath.startsWith("../")) {
+        let otherFolder = relativePath.split("/")[1];
+        if (existsCached("node_modules/" + otherFolder)) {
+            relativePath = "node_modules/" + otherFolder + "/" + relativePath.split("/").slice(2).join("/");
+        }
+    }
+    return "/" + relativePath;
+}
+
+export type PermissionsParameters = {
+    // Each part of the path that matched with a wildcard ("*") is added to this array (in order).
+    pathWildcards: string[];
+    /**
+     *  The path the permissions check matched.
+     *      NOTE: The full path matched is not provided for optimization purposes. Otherwise for large
+     *          writes the permissions check would be needlessly run. IF further depth is required,
+     *          use "*" wildcards. If the depth is dynamic... your structure is probably too complex,
+     *          or something similar to a tree. Destructure it to a list, and all of your
+     *          code will run significantly faster.
+     * 
+     *          TODO: If we ABSOLUTELY need it, we COULD conditionally expose fullPath, and just disable
+     *              optimizations when we do. We could even have a parameter which replaces matchedPath with
+     *              fullPath. But, ideally we don't, as it is just very inefficient...
+     *      NOTE: Usually pathWildcards should be used instead. This is only useful if you want to create
+     *          a very generic permission check which can be used in many hierarchies, and depends on the
+     *          hierarchy (ex, if it checks path.slice(0, 3).users for the users table).
+     **/
+    matchedPath: string;
+    /** The callerMachineId will be unique to the calling machine (but a machine may have multiple,
+            ex, 1 per browser, another a fresh one if they are in incognito mode).
+            - To tie machineIds to userIds simple create a lookup in your database, for example:
+                    `{ machineToUserId: { [machineId: string]: string | undefined } }`
+                Logging out from a machine is simply:
+                    `machineToUserId[machineId] = undefined`
+                A reverse index may also be useful, to efficiently log out everywhere (or just
+                    show all machines that a user is logged into)
+                ```
+                    { userIdToMachineIds: { [userId: string]: { [machineId: string]: 1 } } }
+                   funcion logoutEverywhere(userId: string) {
+                        for (let machineId in userIdToMachineIds[userId]) {
+                            userIdToMachineIds[userId][machineId] = undefined;
+                            machineToUserId[machineId] = undefined;
+                        }
+                    }
+                ```
+     * */
+    callerMachineId: string;
+
+    // IMPORTANT! DO NOT add "matchedValue" here. It is convenient, BUT, it is better for the user
+    //  to access it themselves using pathWildcards. This makes it more typesafe, allowing
+    //  them to find all references and find that reference (otherwise the reference will be hidden).
+    //  - Also, I don't think we could make matchedValue typesafe at all, so it would have to be any,
+    //      which is terrible.
+};
+/** A false of false will deny read permissions, resulting in all reads being given value with a value
+ *      of undefined, and a time of 0.
+ 
+ */
+export type PermissionsCallback = (config: PermissionsParameters) => PermissionsCheckResult;
+export type PermissionsCheckResult = boolean | { allowed: boolean; skipParentChecks?: boolean; };
+/*
+    NOTE: All ancestor permissions checks are applied as well.
+        - This means if the ancestor disallows, it blocks any descendant checks even if they are allowed.
+
+    NOTE: If no permissions match, then access is disallowed by default.
+
+    NOTE: Permissions checks at the root (permissions: { READ_PERMISSIONS(config) { } }) will
+        be used to verify calls are allowed as well, even if the call doesn't read or write any data
+        that is under a permissions check.
+        - THIS MEANS that if there is no permission check at the root, calls won't be allowed by any user
+            (as we default to disallow).
+
+    NOTE: Servers watches ignore permissions, as they directly communicate with the underlying PathValueServer,
+        skipping the ProxyServer.
+        - However function calls by servers are still run by FunctionRunner, which will apply permission checks.
+
+    IMPORTANT! Wildcards are tested via the "" path. This means if the "" key is provided access to a user, they can run
+        Object.keys()/Object.values() on the data. In order to not accidentally provide list access, never allow "" to be
+        a valid path, by never providing access by exclusion. For example:
+            BROKEN: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] !== "admin" || users()[config.callerId].isAdmin; } } }`
+                - This will allow users to access the "admin" data via Object.values(), because the "" !== "admin"
+            BROKEN: `{ admin: { PERMISSIONS(){ return users()[config.callerId].isAdmin; } } }`
+                - Because "" isn't checked
+            CORRECT: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] === config.callerId; } } }`
+            CORRECT: `{ ["*"]: { PERMISSIONS(){ return users()[config.callerId].isAdmin || config.pathWildcards?.[0] === config.callerId; } } }`
+
+    NOTE: Permission checks lag a bit behind data. This means not only will a write that removes checks of itself
+        still be sent (ex, if a user removes their admin access, and only admins can see who is an admin or not,
+        they will be told about their admin change). BUT, a user will receive writes for a bit after that as well!
+        The delay is equal to the network propagation time between two server, which is small (ideally milliseconds),
+        but in the case of excess lag could easily be 10s of seconds (in which case everything on the site would
+        be lagging by 10s of seconds as well).
+
+    For example
+        permissions: {
+            userSecretData: {
+                ["*"]: {
+                    PERMISSIONS(pathWildcards) {
+                        return config.pathWildcards[0] === config.callerMachineId;
+                    }
+                }
+            }
+        }
+*/
+export type SchemaToPermissions<Schema> = {
+    [key in keyof Schema]?: SchemaToPermissions<Schema[key]>;
+} & {
+    PERMISSIONS?: PermissionsCallback;
+} | {
+    PERMISSIONS?: PermissionsCallback;
+};
+
+/** A special key which is prefixed (along with a random value) before special keys used to check child
+ *      permissions. This allows us to explicitly disallow parent syncing (ex Object.keys()) of values.
+ */
+export const CHILD_CHECK_PREFIX = "";
+
+export function hasWildcardMatch(permissionsPath: string[], valuePathParts: string[]): boolean {
+    for (let i = 0; i < permissionsPath.length; i++) {
+        let part = permissionsPath[i];
+        if (part === "*") {
+
+        } else if (part !== valuePathParts[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getWildcardMatches(permissionsPath: string[], valuePathParts: string[]): string[] | undefined {
+    if (permissionsPath.length > valuePathParts.length) return undefined;
+    let wildcardMatches: string[] | undefined;
+    for (let i = 0; i < permissionsPath.length; i++) {
+        let part = permissionsPath[i];
+        if (part === "*") {
+            if (!wildcardMatches) wildcardMatches = [];
+            wildcardMatches.push(valuePathParts[i]);
+        } else if (part !== valuePathParts[i]) {
+            return undefined;
+        }
+    }
+    return wildcardMatches;
+}
+
+let inliningCalls = false;
+export function inlineNestedCalls<T>(code: () => T) {
+    let prev = inliningCalls;
+    inliningCalls = true;
+    try {
+        return code();
+    } finally {
+        inliningCalls = prev;
+    }
+}
+
+type SyncSchemaResult<Schema> = {
+    // NOTE: The functions are over the network, AND, eventually consistent, so it is not possible
+    //  for them to return a result. If a result is required, pass an id which will instruct them where
+    //  to write their result to, and then watch that location.
+    <Functions extends { [name: string]: ((...args: any) => void) }>(config: {
+        domainName?: string;
+        /** NOTE: moduleId is used to store your data in a unique location, that doesn't change
+         *      if you move this file around. Any unique identifier is allowed, as the deploy command
+         *      will warn you if you accidentally reused a moduleId.
+         */
+        moduleId: string;
+        module: NodeJS.Module;
+        functions: Functions;
+        functionMetadata?: { [name in keyof Functions]?: FunctionMetadata<Schema, Functions[name]> };
+        /** Provide access to [Querysub.CALL_PERMISSIONS_KEY] to allow function calls (or provide access at the root). */
+        permissions?: SchemaToPermissions<Schema> & {
+            [CALL_PERMISSIONS_KEY]?: {
+                PERMISSIONS: PermissionsCallback;
+            };
+        };
+    }): SchemaObject<Schema, Functions>;
+};
+
+let prefixes: string[] = [];
+// ONLY used by the deploy process. Path value server is pretty much the only one who needs this, and they aren't including client-side code, and they definitely aren't updating client-side code, so it doesn't make sense to use this directly.
+export function getPrefixesForDeploy(): string[] {
+    return prefixes;
+}
+// Used for some old non syncSchema schema cases
+export function addRoutingPrefixForDeploy(prefix: string) {
+    prefixes.push(prefix);
+}
+
+export function syncSchema<Schema>(): SyncSchemaResult<Schema>;
+export function syncSchema<SchemaDef extends Schema2>(schema: SchemaDef): SyncSchemaResult<Schema2T<SchemaDef>>;
+export function syncSchema<Schema>(schema?: Schema2): SyncSchemaResult<Schema> {
+    return function getFunctions(config) {
+        const { moduleId, functions, module, permissions } = config;
+        const domainName = config.domainName ?? getDomain();
+
+        const data = () => functionSchema()[domainName].PathFunctionRunner[moduleId].Data;
+        let dataCached = lazy(() => data()) as () => Schema;
+
+        let fncs = { ...functions };
+
+        let undoChecksAdded: {
+            name: string;
+            path: SchemaPath;
+        }[] = [];
+        if (schema) {
+            let dataPrefixPath = getPathFromStr(getProxyPath(data));
+            let fnc = getSpecFromModule(module);
+            // NOTE: We call syncSchema a lot, so we default the git hash. However, for modules that provide
+            //  functions we call as synced functions, we SHOULD have a real hash here.
+            let gitHash = fnc?.gitRef || "ambient";
+            registerSchema({ domainName, moduleId, schema, gitHash });
+
+            let gcDefs = Schema2Fncs.getGCObjects(schema);
+            for (let { path, gcDelay } of gcDefs) {
+                createObjectAliveChecker(data, path, gcDelay);
+            }
+
+
+            let undoChecks = Schema2Fncs.getAllUndoChecks(schema);
+            for (let checkObj of undoChecks) {
+                // Need at least one check
+                if (checkObj.undoChecks.length === 0) continue;
+                function niceSchemaPath(path: SchemaPath) {
+                    return path.map(x => x === Schema2Fncs.WildCard ? "*" : x).join(".");
+                }
+                let name = `__undoer__${niceSchemaPath(checkObj.path)}`;
+                let fullPath = (dataPrefixPath as SchemaPath).concat(checkObj.path);
+                undoChecksAdded.push({
+                    name,
+                    path: fullPath,
+                });
+                (fncs as any)[name] = function undoCallback(path: string[], value: unknown) {
+                    if (!isChildPath(fullPath, path)) {
+                        throw new Error(`Tried to access undo function with path not under undo spec ${niceSchemaPath(fullPath)} . Tried to use path ${path.join(".")}`);
+                    }
+
+                    let permissionsChecker = proxyWatcher.getTriggeredWatcher().permissionsChecker;
+                    if (permissionsChecker) {
+                        let permissionsCheck = permissionsChecker.checkPermissions(getPathStr(path));
+                        if (!permissionsCheck?.allowed) {
+                            throw new Error(`Failed read permission check for undo call at path ${path.join(".")}`);
+                        }
+                    }
+                    for (let check of checkObj.undoChecks) {
+                        let nestedPath = path.slice(0, fullPath.length);
+                        let key = nestedPath[nestedPath.length - 1];
+                        if (!atomic(check(key, nestedPath))) {
+                            throw new Error(`Failed undo permission check at path ${nestedPath.join(".")}, check ${check.name || check.toString().slice(0, 100)}`);
+                        }
+                    }
+                    let parent = rawSchema()() as any;
+                    for (let i = 0; i < path.length - 1; i++) {
+                        parent = parent[path[i]];
+                    }
+                    let key = path[path.length - 1];
+
+                    // NOTE: This isn't an atomic set, because we leave it up proxyWatcher (and schema2)
+                    //  to correctly handle assigning the values atomically.
+                    parent[key] = value;
+                };
+            }
+
+            // Register all root lookups as prefixes.
+            let dataRoot = getProxyPath(() => functionSchema()[getDomain()].PathFunctionRunner[moduleId].Data);
+            let paths = Schema2Fncs.getLookups(schema).map(x =>
+                joinPathStres(dataRoot, getPathStr(x))
+            );
+            // NOTE: This will break with wildcards, but... we also take only the highest level lookups, so it shouldn't be an issue
+            sort(paths, x => x.length);
+            let rootLookups = new Set<string>();
+            for (let path of paths) {
+                let parts = getPathFromStr(path);
+                // Don't add if any of our ancestors are added
+                function hasAncestor() {
+                    for (let i = 0; i < parts.length - 1; i++) {
+                        let ancestorPath = getPathStr(parts.slice(0, i));
+                        if (rootLookups.has(ancestorPath)) return true;
+                    }
+                }
+                if (!hasAncestor()) {
+                    rootLookups.add(path);
+                    prefixes.push(path);
+                }
+            }
+        }
+
+        let wrappedFunctions: { [name: string]: (...args: any) => CallSpec } = Object.create(null);
+        let functionMetadata = config.functionMetadata;
+        for (let [name, fnc] of Object.entries(fncs)) {
+            let metadata = functionMetadata?.[name] ?? {};
+            let debugging = false;
+            wrappedFunctions[name] = Object.assign((...args: any[]): any => {
+                if (inliningCalls) {
+                    return fnc(...args);
+                }
+                if (debugging) {
+                    debugger;
+                }
+                return writeFunctionCall({
+                    domainName,
+                    moduleId,
+                    functionId: name,
+                    args,
+                    metadata: metadata as FunctionMetadata
+                });
+            }, {
+                debug() {
+                    debugging = true;
+                }
+            });
+            if (metadata.keyOverride) {
+                let { getPrefix, getKey } = metadata.keyOverride;
+                let prefix = getProxyPath(() => getPrefix(dataCached));
+                if (!prefix) throw new Error(`Key override getPrefix returned a non-proxy, ${getPrefix.toString()}`);
+                let objs = callIdOverrideFncs.get(config.moduleId);
+                if (!objs) {
+                    objs = new Map();
+                    callIdOverrideFncs.set(config.moduleId, objs);
+                }
+                objs.set(name, {
+                    prefix,
+                    getKey: getKey as any,
+                });
+            }
+        }
+
+        for (let check of undoChecksAdded) {
+            registeredUndoChecks.push({
+                path: check.path,
+                undoSet: wrappedFunctions[check.name] as any,
+            });
+        }
+
+        let permissionsNonWildcards = new Map<string, PermissionsCallback>();
+        let permissionsWildcards: { pathParts: string[]; callback: PermissionsCallback }[] = [];
+        addPermissions(rootPathStr, permissions);
+        function addPermissions(path: string, permissions: SchemaToPermissions<Schema> | undefined) {
+            if (!permissions) return;
+            for (let key of getStringKeys(permissions)) {
+                if (key === "PERMISSIONS") {
+                    let value = permissions.PERMISSIONS;
+                    if (value) {
+                        if (path.includes("*")) {
+                            permissionsWildcards.push({
+                                pathParts: getPathFromStr(path),
+                                callback: value,
+                            });
+                        } else {
+                            permissionsNonWildcards.set(path, value);
+                        }
+                    }
+                } else {
+                    addPermissions(appendToPathStr(path, key), permissions[key]);
+                }
+            }
+        }
+        // Sort reversed, so the most specific checks are first
+        permissionsWildcards.sort((b, a) => a.pathParts.length - b.pathParts.length);
+
+        // NOTE: We cache the root with lazy, to save time evaluating each proxy on each access. Also, it reduces the extra paths accesses that will never have data.
+        //  - Permissions should be fine, as we check them directly (if the user wants a path we check it), so we don't throw on accessing the root data and then allow all child accesses (each path is checked independently).
+        let result: SchemaObject = {
+            data: dataCached,
+            domainName,
+            moduleId,
+            functions: wrappedFunctions as any,
+            functionMetadata: functionMetadata as any,
+            rawFunctions: fncs,
+            permissions,
+            permissionsNonWildcards,
+            permissionsWildcards,
+        };
+
+        if (!isHotReloading() && module.exports[SCHEMA_EXPORT_KEY]) {
+            throw new Error(`Module ${moduleId} already has a schema. Only 1 schema is allowed per module.`);
+        }
+
+        // NOTE: We clobber the previous value, as we might just be hotreloading, which
+        //  could mean the exports value has our previous value.
+        module.exports[SCHEMA_EXPORT_KEY] = result;
+        developmentModules.set(moduleId, module);
+        return result;
+    };
+}
+let developmentModules = new Map<string, NodeJS.Module>();
+
+export function getDevelopmentModule(moduleId: string): NodeJS.Module | undefined {
+    return developmentModules.get(moduleId);
+}
+export function getAllDevelopmentModulesIds(): string[] {
+    return Array.from(developmentModules.keys());
+}
+
+function isChildPath(spec: SchemaPath, path: string[]): boolean {
+    if (spec.length > path.length) return false;
+    for (let i = 0; i < spec.length; i++) {
+        if (spec[i] === Schema2Fncs.WildCard) continue;
+        if (spec[i] !== path[i]) return false;
+    }
+    return true;
+}
+
+// pathStr => ...
+let registeredUndoChecks: {
+    path: SchemaPath;
+    undoSet: (nestedPath: string[], value: unknown) => void;
+}[] = [];
+
+export function registerUndoCallback(path: SchemaPath, undoSet: (nestedPath: string[], value: unknown) => void) {
+    registeredUndoChecks.push({ path, undoSet });
+}
+
+/** Throws if there is no undo callback available at this path. */
+export function getUndoCallback(path: string[]): {
+    setValue(path: string[], value: unknown): void;
+} {
+    // Local undos are always allowed
+    if (path[0] === LOCAL_DOMAIN) {
+        return {
+            setValue(path, value) {
+                if (path[0] !== LOCAL_DOMAIN) throw new Error(`Cannot set non-local value with local undo function. Tried to use path ${path.join(".")}`);
+                let parent = rawSchema()() as any;
+                for (let i = 0; i < path.length - 1; i++) {
+                    parent = parent[path[i]];
+                }
+                let key = path[path.length - 1];
+                parent[key] = value;
+            }
+        };
+    }
+    // Any callback should be fine?
+    let undoCallbacks = registeredUndoChecks.filter(x => isChildPath(x.path, path));
+    sort(undoCallbacks, x => -x.path.length);
+    if (undoCallbacks.length === 0) {
+        throw new Error(`No undo callback available at path ${path.join(".")}. There needs to be an undo region at or above this path, via t.undoRegion`);
+    }
+    return { setValue: undoCallbacks[0].undoSet };
+}
+
+function createObjectAliveChecker(data: () => any, path: SchemaPath, delay: number | undefined) {
+    registerAliveChecker({
+        object(wildcard) {
+            let obj = data();
+            for (let part of path) {
+                if (part === Schema2Fncs.WildCard) {
+                    obj = obj[wildcard];
+                } else {
+                    obj = obj[part];
+                }
+            }
+            return obj;
+        },
+        isAlive(value, path) {
+            let parent = rawSchema()() as any;
+            for (let i = 0; i < path.length - 1; i++) {
+                parent = parent[path[i]];
+            }
+            let key = path[path.length - 1];
+            let isAlive = key in parent;
+            return isAlive;
+        },
+        deleteDelayTime: delay,
+        // NOTE: This is actually safe, as we only read a single value, and are really
+        //  just looking to see if ANYTHING has created the value. Without this there is
+        //  a large gap when the value could be deleted, then undeleted, and then
+        //  as we only read old values we might not see the undelete. WITH this the gap
+        //  is much smaller (but still there).
+        unsafeLiveReads: true,
+    });
+}
+
+let callIdOverrideFncs: Map<string, Map<string, {
+    prefix: string;
+    getKey: (...args: unknown[]) => string;
+}>> = new Map();
+export function getCallIdOverride(config: {
+    moduleId: string;
+    functionId: string;
+    callId: string;
+    args: unknown[];
+}): string {
+    let def = callIdOverrideFncs.get(config.moduleId)?.get(config.functionId);
+    if (!def) return config.callId;
+    return createRoutingOverrideKey({
+        remappedPrefix: def.prefix,
+        originalKey: config.callId,
+        routeKey: def.getKey(...config.args),
+    });
 }