querysub 0.403.0 → 0.405.0

package/src/diagnostics/pathAuditer.ts

@@ -0,0 +1,486 @@
+import { binarySearchBasic2, timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { PathRouter } from "../0-path-value-core/PathRouter";
+import { authorityStorage, MAX_CHANGE_AGE, PathValue, compareTime, Time, createMissingEpochValue, epochTime } from "../0-path-value-core/pathValueCore";
+import { formatNumber, formatPercent, formatTime } from "socket-function/src/formatting/format";
+import { timeoutToError } from "../errors";
+import { setPathInteractedCallback } from "./pathAuditerCallback";
+import { registerResource } from "./trackResources";
+import { registerMeasureInfo } from "socket-function/src/profiling/measure";
+import { lazy } from "socket-function/src/caching";
+import { runInfinitePoll, runInSerial } from "socket-function/src/batching";
+import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { validStateComputer } from "../0-path-value-core/ValidStateComputer";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { decodeNodeId } from "../-a-auth/certs";
+import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
+import { assertIsManagementUser } from "./managementPages";
+import { isNode } from "typesafecss";
+import { isClient } from "../config2";
+import { isLocal } from "../config";
+import { pathWatcher } from "../0-path-value-core/PathWatcher";
+
+if (!isClient()) {
+    // Comment this line out to disable our functionality
+    // NOTE: I think this should stay on even in production because it should be able to fix lots of issues. 
+    setPathInteractedCallback(onPathInteracted);
+}
+
+const CHECK_INTERVAL = timeInMinute * 3;
+const AUDIT_PATHS_PER_CHECK = 1000;
+const DROP_AGE_THRESHOLD = CHECK_INTERVAL * 5;
+
+const ERROR_AGE_THRESHOLD = timeInMinute;
+const WARN_THRESHOLD = timeInSecond * 5;
+const AUDIT_TIMEOUT = timeInMinute * 2;
+
+type PathInteractionPriority = 0 | 1 | 2;  // 0: read, 1: write, 2: rejected (higher is more important)
+
+interface PathInteraction {
+    path: string;
+    time: number;
+}
+
+interface AuditStats {
+    totalAudited: number;
+    totalDiscarded: number;
+    errorCount: number;
+    warningCount: number;
+    fixedCount: number;
+}
+
+interface PendingValidityCheck {
+    path: string;
+    ourTimeId: number;
+    remoteTimeId: number | undefined;
+    ourValid: boolean;
+    remoteValid: boolean | undefined;
+    remoteNodeId: string;
+    discoveredAt: number;
+}
+
+class CyclicList<T> {
+    private items: (T | undefined)[];
+    private startIndex: number = 0;
+    private count: number = 0;
+    private capacity: number;
+
+    constructor(capacity: number) {
+        this.capacity = capacity;
+        this.items = new Array(capacity);
+    }
+
+    public push(item: T): void {
+        let writeIndex = (this.startIndex + this.count) % this.capacity;
+        this.items[writeIndex] = item;
+        if (this.count < this.capacity) {
+            this.count++;
+        } else {
+            this.startIndex = (this.startIndex + 1) % this.capacity;
+        }
+    }
+
+    public length(): number {
+        return this.count;
+    }
+
+    public at(index: number): T {
+        if (index >= this.count) throw new Error(`Index ${index} is out of bounds for list of length ${this.count}`);
+        let actualIndex = (this.startIndex + index) % this.capacity;
+        let item = this.items[actualIndex];
+        if (item === undefined) throw new Error(`Item at index ${index} is undefined`);
+        return item;
+    }
+
+    public shift(count: number): void {
+        let toRemove = Math.min(count, this.count);
+        this.startIndex = (this.startIndex + toRemove) % this.capacity;
+        this.count -= toRemove;
+    }
+}
+
+const CYCLIC_LIST_CAPACITY = 100000;
+
+const pathLists: CyclicList<PathInteraction>[] = [
+    new CyclicList<PathInteraction>(CYCLIC_LIST_CAPACITY),  // priority 0: read
+    new CyclicList<PathInteraction>(CYCLIC_LIST_CAPACITY),  // priority 1: write
+    new CyclicList<PathInteraction>(CYCLIC_LIST_CAPACITY),  // priority 2: rejected
+];
+
+let lastAuditTime: number = 0;
+let stats: AuditStats = {
+    totalAudited: 0,
+    totalDiscarded: 0,
+    errorCount: 0,
+    warningCount: 0,
+    fixedCount: 0,
+};
+
+const pendingValidityChecks: PendingValidityCheck[] = [];
+const pendingValidityCheckPaths = new Set<string>();
+
+function onPathInteracted(path: string, priority: PathInteractionPriority): void {
+    if (PathRouter.isLocalPath(path)) return;
+    ensureAuditing();
+    pathLists[priority].push({ path, time: Date.now() });
+}
+
+const ensureAuditing = lazy(() => {
+    runInfinitePoll(CHECK_INTERVAL, runAuditNowSerial);
+});
+
+const runAuditNowSerial = runInSerial(runAuditNow);
+
+async function runAuditNow() {
+    await PathRouter.waitUntilReady();
+    let now = Date.now();
+
+    let pathsToAudit = new Set<string>();
+    let perList = Math.floor(AUDIT_PATHS_PER_CHECK / pathLists.length);
+
+    for (let priority = 0; priority < pathLists.length; priority++) {
+        let list = pathLists[priority];
+        let len = list.length();
+
+        let splitIndex = 0;
+        for (let i = 0; i < len; i++) {
+            let item = list.at(i);
+            if (item && item.time > lastAuditTime) {
+                splitIndex = i;
+                break;
+            }
+        }
+
+        let takeAfter = Math.min(Math.floor(perList / 2), len - splitIndex);
+        let takeBefore = Math.min(perList - takeAfter, splitIndex);
+
+        for (let i = 0; i < takeAfter; i++) {
+            pathsToAudit.add(list.at(splitIndex + i).path);
+        }
+
+        for (let i = 0; i < takeBefore; i++) {
+            pathsToAudit.add(list.at(i).path);
+        }
+
+        let discarded = 0;
+        for (let i = 0; i < len; i++) {
+            let item = list.at(i);
+            if (now - item.time > DROP_AGE_THRESHOLD) {
+                discarded++;
+            } else {
+                break;
+            }
+        }
+        list.shift(discarded);
+        stats.totalDiscarded += discarded;
+    }
+
+    lastAuditTime = now;
+    let paths = Array.from(pathsToAudit);
+    // If we stopped watching it, or were never watching it in the first place, we don't want to audit it. Or if we haven't finished watching it anyways.
+    paths = paths.filter(path => pathWatcher.isWatching(path) && authorityStorage.isSynced(path) || PathRouter.isSelfAuthority(path));
+    if (paths.length === 0) return;
+
+    let pathObjs: { path: string }[] = paths.map(path => ({ path }));
+    let valuesByAuthority = PathRouter.getAllAuthoritiesForValues(pathObjs);
+
+    await Promise.all(
+        Array.from(valuesByAuthority.entries()).map(([nodeId, pathsToTest]) =>
+            timeoutToError(
+                AUDIT_TIMEOUT,
+                auditAuthority(nodeId, pathsToTest, now),
+                () => new Error(`Path audit timed out for node ${nodeId}`)
+            )
+        )
+    );
+
+    await processPendingValidityChecks(now);
+}
+
+async function processPendingValidityChecks(now: number) {
+    let threshold = now - MAX_CHANGE_AGE;
+    let splitIndex = binarySearchBasic2(pendingValidityChecks, check => check.discoveredAt, { discoveredAt: threshold } as PendingValidityCheck);
+    if (splitIndex < 0) splitIndex = ~splitIndex;
+
+    for (let i = 0; i < splitIndex; i++) {
+        let pendingCheck = pendingValidityChecks[i];
+        let currentValue = authorityStorage.getValueAtTime(pendingCheck.path);
+        if (currentValue && currentValue.valid && currentValue.time !== epochTime) {
+            trackSyncAge({
+                path: pendingCheck.path,
+                ourTimeId: pendingCheck.ourTimeId,
+                remoteTimeId: pendingCheck.remoteTimeId,
+                ourValid: pendingCheck.ourValid,
+                remoteValid: pendingCheck.remoteValid,
+                remoteNodeId: pendingCheck.remoteNodeId,
+                reason: "Pending validity check aged past MAX_CHANGE_AGE. Forcing sync to all nodes.",
+            });
+            let allAuthorities = PathRouter.getAllAuthoritiesForValues([currentValue]);
+            for (let [authorityNodeId, _] of allAuthorities.entries()) {
+                let serialized = await pathValueSerializer.serialize([currentValue]);
+                await PathAuditerController.nodes[authorityNodeId].ingestPathValues(serialized);
+            }
+        }
+    }
+
+    if (splitIndex > 0) {
+        for (let i = 0; i < splitIndex; i++) {
+            pendingValidityCheckPaths.delete(pendingValidityChecks[i].path);
+        }
+        pendingValidityChecks.splice(0, splitIndex);
+    }
+}
+
+function trackSyncAge(config: {
+    path: string;
+    ourTimeId: number;
+    remoteTimeId: number | undefined;
+    ourValid: boolean;
+    remoteValid: boolean | undefined;
+    remoteNodeId: string;
+    reason: string;
+}) {
+    let age = Date.now() - config.ourTimeId;
+    if (age >= ERROR_AGE_THRESHOLD) {
+        stats.errorCount++;
+        console.error(config.reason, {
+            path: config.path,
+            age,
+            ourTimeId: config.ourTimeId,
+            remoteTimeId: config.remoteTimeId,
+            ourValid: config.ourValid,
+            remoteValid: config.remoteValid,
+            remoteNodeId: config.remoteNodeId,
+            remoteNodeThreadId: decodeNodeId(config.remoteNodeId)?.threadId,
+        });
+    } else if (age >= WARN_THRESHOLD) {
+        stats.warningCount++;
+        console.warn(config.reason, {
+            path: config.path,
+            age,
+            ourTimeId: config.ourTimeId,
+            remoteTimeId: config.remoteTimeId,
+            ourValid: config.ourValid,
+            remoteValid: config.remoteValid,
+            remoteNodeId: config.remoteNodeId,
+            remoteNodeThreadId: decodeNodeId(config.remoteNodeId)?.threadId,
+        });
+    } else {
+        stats.fixedCount++;
+    }
+}
+
+async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[], now: number) {
+    let requests: PathTimeRequest[] = [];
+
+    for (let pathObj of pathsToAudit) {
+        let path = pathObj.path;
+        let ourLatest = authorityStorage.getValueAtTime(path);
+
+        // Ask for their latest valid (time: undefined means latest)
+        requests.push({ path, time: undefined });
+
+        if (ourLatest?.time) {
+            // Ask for their state at our specific time
+            requests.push({ path, time: ourLatest.time });
+        }
+
+        let history = authorityStorage.getValuePlusHistory(path);
+        if (history.length > 1) {
+            let randomIndex = Math.floor(Math.random() * (history.length - 1)) + 1;
+            let randomValue = history[randomIndex];
+            requests.push({ path, time: randomValue.time });
+        }
+    }
+
+    let responses = await PathAuditerController.nodes[nodeId].getValidStates(requests);
+
+    let valuesToRequest: PathTimeRequest[] = [];
+    let valuesToSend: PathValue[] = [];
+    let pathsToForceSync = new Set<string>();
+
+    for (let response of responses) {
+        let ourValue = authorityStorage.getValueAtTime(response.path) || createMissingEpochValue(response.path);
+        if (ourValue.isTransparent && response.isTransparent) continue;
+
+        // it's latest valid is newer than ours
+        //      - Ask it for the value of the latest
+        if (response.valid && response.time && compareTime(response.time, ourValue.time) > 0) {
+            valuesToRequest.push({ path: response.path, time: response.time });
+            let authorities = PathRouter.getAllAuthorities(response.path);
+            require("debugbreak")(2);
+            debugger;
+            trackSyncAge({
+                path: response.path,
+                ourTimeId: ourValue.time.time,
+                remoteTimeId: response.time.time,
+                ourValid: ourValue.valid ?? false,
+                remoteValid: response.valid,
+                remoteNodeId: nodeId,
+                reason: "Remote has newer latest value, asking for it",
+            });
+        }
+        // Our latest valid = server does not have & it's latest valid is older than ours
+        //      - Send it our value
+        else if (response.valid === undefined && (!response.time || compareTime(ourValue.time, response.time) > 0)) {
+            valuesToSend.push(ourValue);
+            require("debugbreak")(2);
+            debugger;
+            trackSyncAge({
+                path: response.path,
+                ourTimeId: ourValue.time.time,
+                remoteTimeId: response.time?.time,
+                ourValid: ourValue.valid ?? false,
+                remoteValid: response.valid,
+                remoteNodeId: nodeId,
+                reason: "Remote is missing our value, sending it to them",
+            });
+        }
+        // Our latest valid = server has, but says it's not valid
+        //      - If time < MAX_CHANGE_AGE old, record this, and wait until MAX_CHANGE_AGE (put it in some other kind of queue), and then check again
+        //      - If time >= MAX_CHANGE_AGE old, then tell it to change it's valid state to ours. Also, tell all other authorities that use this path.
+        // NOTE: We skew towards making values valid instead of invalid. So if there's disagreement, we always take the valid value instead of the invalid value.
+        // NOTE: The opposite case, if the remote is valid and ours is invalid, is handled by our latest value being older than the remote value, as we're never going to ask about an invalid value. It'll just implicitly change what the latest valid value is. 
+        else if (!response.valid && ourValue.valid && ourValue.time !== epochTime) {
+            let age = now - ourValue.time.time;
+            if (age >= MAX_CHANGE_AGE) {
+                pathsToForceSync.add(response.path);
+                require("debugbreak")(2);
+                debugger;
+                trackSyncAge({
+                    path: response.path,
+                    ourTimeId: ourValue.time.time,
+                    remoteTimeId: response.time?.time,
+                    ourValid: ourValue.valid,
+                    remoteValid: response.valid,
+                    remoteNodeId: nodeId,
+                    reason: "Remote says our value is invalid, but we think it's valid. Telling all nodes about this value to ensure it's in sync everywhere.",
+                });
+            } else {
+                if (!pendingValidityCheckPaths.has(response.path)) {
+                    let newCheck: PendingValidityCheck = {
+                        path: response.path,
+                        ourTimeId: ourValue.time.time,
+                        remoteTimeId: response.time?.time,
+                        ourValid: ourValue.valid ?? false,
+                        remoteValid: response.valid,
+                        remoteNodeId: nodeId,
+                        discoveredAt: now,
+                    };
+                    let insertIndex = binarySearchBasic2(pendingValidityChecks, check => check.discoveredAt, newCheck);
+                    if (insertIndex < 0) insertIndex = ~insertIndex;
+                    pendingValidityChecks.splice(insertIndex, 0, newCheck);
+                    pendingValidityCheckPaths.add(response.path);
+                }
+            }
+        }
+    }
+
+    if (valuesToRequest.length > 0) {
+        let receivedValues = await PathAuditerController.nodes[nodeId].getPathValues(valuesToRequest);
+        if (receivedValues.length > 0) {
+            validStateComputer.ingestValuesAndValidStates({
+                pathValues: receivedValues,
+                parentSyncs: [],
+                initialTriggers: { values: new Set(), parentPaths: new Set() },
+            });
+        }
+    }
+
+    if (valuesToSend.length > 0) {
+        let serialized = await pathValueSerializer.serialize(valuesToSend);
+        await PathAuditerController.nodes[nodeId].ingestPathValues(serialized);
+    }
+
+    if (pathsToForceSync.size > 0) {
+        for (let path of pathsToForceSync) {
+            let valueToForce = authorityStorage.getValueAtTime(path);
+            if (valueToForce) {
+                let allAuthorities = PathRouter.getAllAuthoritiesForValues([valueToForce]);
+                for (let [authorityNodeId, _] of allAuthorities.entries()) {
+                    let serialized = await pathValueSerializer.serialize([valueToForce]);
+                    await PathAuditerController.nodes[authorityNodeId].ingestPathValues(serialized);
+                }
+            }
+        }
+    }
+
+    stats.totalAudited += pathsToAudit.length;
+}
+
+type PathTimeRequest = {
+    path: string;
+    time?: { time: number; version: number; creatorId: number };
+};
+
+type ValidStateResponse = {
+    path: string;
+    time?: { time: number; version: number; creatorId: number };
+    valid: boolean | undefined;
+    isTransparent: boolean;
+};
+
+class PathAuditerService {
+    public async getValidStates(requests: PathTimeRequest[]): Promise<ValidStateResponse[]> {
+        let results: ValidStateResponse[] = [];
+        for (let request of requests) {
+            let value = authorityStorage.getValueAtTime(request.path, request.time);
+            results.push({
+                path: request.path,
+                time: value?.time,
+                valid: value === undefined ? undefined : value.valid,
+                isTransparent: !!value?.isTransparent,
+            });
+        }
+        return results;
+    }
+
+    public async getPathValues(requests: PathTimeRequest[]): Promise<PathValue[]> {
+        let results: PathValue[] = [];
+        for (let request of requests) {
+            let value = authorityStorage.getValueAtTime(request.path, request.time);
+            if (value) {
+                results.push(value);
+            }
+        }
+        return results;
+    }
+
+    public async ingestPathValues(serializedValues: Buffer[]): Promise<void> {
+        let values = await pathValueSerializer.deserialize(serializedValues);
+        validStateComputer.ingestValuesAndValidStates({
+            pathValues: values,
+            parentSyncs: [],
+            initialTriggers: { values: new Set(), parentPaths: new Set() },
+        });
+    }
+
+    public async runAuditNow_forBrowser(nodeId: string): Promise<void> {
+        await PathAuditerController.nodes[nodeId].runAuditNow();
+    }
+
+    public async runAuditNow(): Promise<void> {
+        await runAuditNowSerial();
+    }
+}
+
+export const PathAuditerController = SocketFunction.register(
+    "PathAuditerService-019d324f-9058-71ab-b1d0-384f9418d35b",
+    new PathAuditerService(),
+    () => ({
+        getValidStates: {},
+        getPathValues: {},
+        ingestPathValues: {},
+        runAuditNow_forBrowser: {},
+        runAuditNow: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    })
+);
+
+registerMeasureInfo(() => {
+    if (stats.totalDiscarded === 0) return "";
+    let percentage = formatPercent(stats.totalAudited / (stats.totalAudited + stats.totalDiscarded) * 100);
+    return `AUDIT ${formatNumber(stats.totalAudited)} (${percentage}) E:${stats.errorCount} W:${stats.warningCount} F:${stats.fixedCount} `;
+});

package/src/diagnostics/pathAuditerCallback.ts

@@ -0,0 +1,20 @@
+let callback: ((path: string, priority: 0 | 1 | 2) => void) | undefined;
+
+let disabled = false;
+/*
+    0: read
+    1: write
+    2: rejected
+    (higher is more important)
+*/
+export function onPathInteracted(path: string, priority: 0 | 1 | 2) {
+    if (disabled) return;
+    callback?.(path, priority);
+}
+export function setPathInteractedCallback(_callback: ((path: string, priority: 0 | 1 | 2) => void) | undefined) {
+    callback = _callback;
+}
+
+export function disablePathAuditer() {
+    disabled = true;
+}

package/src/diagnostics/watchdog.ts

@@ -7,9 +7,11 @@ import { registerPeriodic } from "./periodic";
 import { getOwnMachineId } from "../-a-auth/certs";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { formatPercent, formatTime } from "socket-function/src/formatting/format";
-import { pathWatcher } from "../0-path-value-core/pathValueCore";
+import { pathWatcher } from "../0-path-value-core/PathWatcher";
 import { addStatPeriodic, addStatSumPeriodic, addTimeProfileDistribution, registerNodeMetadata } from "../-0-hooks/hooks";
 import { logDisk } from "./logs/diskLogger";
+import { getDebuggerUrl } from "./listenOnDebugger";
+import { isPublic } from "../config";
 
 let lastProfile: MeasureProfile | undefined;
 
@@ -87,6 +89,11 @@ function logProfileMeasuresTimingsNow() {
         minTimeToLog: minTimeToLog,
     }));
 
+    if (isNode() && !isPublic()) {
+        let debuggerValue = getDebuggerUrl();
+        process.stdout.write(`\n${debuggerValue}\n`);
+    }
+
     lastProfile = profile;
     // if (isNode()) {
     //     if (SocketFunction.mountedNodeId) {

package/src/library-components/URLParam.ts

@@ -2,7 +2,6 @@
 
 import { deepCloneJSON, throttleFunction, timeInMinute } from "socket-function/src/misc";
 import { isNode } from "typesafecss";
-import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
 import { atomicObjectRead, doAtomicWrites, noAtomicSchema, proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
 import { syncSchema } from "../3-path-functions/syncSchema";
 import { Querysub } from "../4-querysub/QuerysubController";
@@ -12,6 +11,7 @@ import { logErrors } from "../errors";
 import { canHaveChildren } from "socket-function/src/types";
 import { URLOverride } from "./ATag";
 import { lazy } from "socket-function/src/caching";
+import { LOCAL_DOMAIN } from "../0-path-value-core/PathRouter";
 
 export interface URLParam<T = unknown> {
     value: T;

package/src/misc/hash.ts

@@ -1,5 +1,6 @@
 import debugbreak from "debugbreak";
 
+/** Returns an integer */
 export function fastHash(text: string): number {
     // Murmur, but we try to use more than 32 bits, as a double can store far more than 32 bits.
     let hash1 = 5380942 ^ text.length;

package/src/path.ts

@@ -85,6 +85,10 @@ export function getPathStr4(path0: string, path1: string, path2: string, path3:
 }
 
 export function appendToPathStr(pathStr: string, pathPart: string) {
+    if (pathStr[pathStr.length - 1] !== pathDelimitChar) {
+        // Might be a hacked path
+        pathStr = hack_stripPackedPath(pathStr);
+    }
     return pathStr + escapePathPart(pathPart) + pathDelimitEscaped;
 }
 export function prependToPathStr(pathStr: string, pathPart: string) {
@@ -143,28 +147,38 @@ export function getPathAfterLastChild(pathStr: string) {
     return pathStr.slice(0, -pathDelimitEscaped.length) + afterChildSuffix;
 }
 
+function getStartOfLastPart(pathStr: string) {
+    // I'm not sure if this is what we should be doing for hacked paths. In theory, a hacked path basically represents select these children, selecting specific children. So, in theory, that should mean... The parent is the parent of those children. However, we also use it to keep track of the parent sync, in which case we are syncing the parent. And so the parent we want, if we ever recall this, would be actually the parent of that. So I think in theory we should uncomment this code, but in practice we need to keep it commented. 
+    // if(hack_isPackedPath(pathStr)) {
+    //     let index = pathStr.lastIndexOf(pathDelimitEscaped);
+    //     if(index < 0) return pathStr.length;
+    //     return index + pathDelimitEscaped.length;
+    // }
+    let index = pathStr.lastIndexOf(pathDelimitEscaped);
+    if (index < 0) return pathStr.length;
+    let index2 = pathStr.lastIndexOf(pathDelimitEscaped, index - 1);
+    if (index2 < 0) return 0;
+    return index2 + pathDelimitEscaped.length;
+}
+
 /** === getPathStr(getPathFromStr(pathStr).slice(0, -1)), getParentPathStr(rootPathStr) === rootPathStr */
 export function getParentPathStr(pathStr: string) {
     // Allow empty string? Better than throwing on it, I guess
     if (pathStr === "") {
         return "";
     }
-    // NOTE: If pathStr.length is too small, our index start becomes negative, and so this works without
     //  an additional check.
-    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
-    return pathStr.slice(0, index + pathDelimitEscaped.length);
+    return pathStr.slice(0, getStartOfLastPart(pathStr));
 }
 
 /** === getPathFromStr(pathStr).slice(-1)[0] */
 export function getLastPathPart(pathStr: string) {
-    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
-    return unescapePathPart(pathStr.slice(index + pathDelimitEscaped.length, -pathDelimitEscaped.length));
+    return unescapePathPart(pathStr.slice(getStartOfLastPart(pathStr) - pathDelimitEscaped.length, -pathDelimitEscaped.length));
 }
 
 /** === getPathStr(getPathFromStr(pathStr).slice(0, -1)) */
 export function removePathLastPart(pathStr: string) {
-    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
-    return pathStr.slice(0, index + pathDelimitEscaped.length);
+    return pathStr.slice(0, getStartOfLastPart(pathStr));
 }
 
 /** getPathDepth(pathStr) === getPathFromStr(pathStr).length */