@openclaw/fs-safe 0.16.0 → 0.18.0

package/dist/strict-file-identity.js

@@ -40,19 +40,19 @@ export async function inspectFileIdentity(inspect, expected, platform = process.
     }
     throw identityMismatch();
 }
-export function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
+export function inspectFileIdentitySync(inspect, expected, platform = process.platform, mismatch = identityMismatch) {
     let knownDev;
     let knownIno;
     if (expected) {
         knownDev = expected.dev;
         if (typeof knownDev !== "bigint")
-            throw identityMismatch();
+            throw mismatch();
         knownIno = expected.ino;
         if (typeof knownIno !== "bigint")
-            throw identityMismatch();
+            throw mismatch();
         // An unknown expected device must not bypass observation of its inode.
         if (platform === "win32" && (knownDev === 0n || knownIno === 0n))
-            throw identityMismatch();
+            throw mismatch();
     }
     for (let attempt = 0; attempt < 2; attempt++) {
         const stat = inspect();
@@ -61,28 +61,28 @@ export function inspectFileIdentitySync(inspect, expected, platform = process.pl
         // a checker closure, known-component object, or field array per inspection.
         const dev = stat.dev;
         if (typeof dev !== "bigint")
-            throw identityMismatch();
+            throw mismatch();
         if (platform === "win32" && dev === 0n) {
             complete = false;
         }
         else {
             if (knownDev !== undefined && knownDev !== dev)
-                throw identityMismatch();
+                throw mismatch();
             knownDev = dev;
         }
         const ino = stat.ino;
         if (typeof ino !== "bigint")
-            throw identityMismatch();
+            throw mismatch();
         if (platform === "win32" && ino === 0n) {
             complete = false;
         }
         else {
             if (knownIno !== undefined && knownIno !== ino)
-                throw identityMismatch();
+                throw mismatch();
             knownIno = ino;
         }
         if (complete)
             return stat;
     }
-    throw identityMismatch();
+    throw mismatch();
 }

package/dist/string-coerce.d.ts

@@ -2,4 +2,3 @@ export declare function normalizeNullableString(value: unknown): string | null;
 export declare function normalizeOptionalString(value: unknown): string | undefined;
 export declare function normalizeOptionalLowercaseString(value: unknown): string | undefined;
 export declare function normalizeLowercaseStringOrEmpty(value: unknown): string;
-//# sourceMappingURL=string-coerce.d.ts.map

package/dist/suppressed-error.d.ts

@@ -3,4 +3,3 @@ export type SuppressedErrorLike = Error & {
     suppressed: unknown;
 };
 export declare function createSuppressedError(error: unknown, suppressed: unknown, message: string): SuppressedErrorLike;
-//# sourceMappingURL=suppressed-error.d.ts.map

package/dist/symlink-parents.d.ts

@@ -9,4 +9,3 @@ export type AssertNoSymlinkParentsOptions = {
 };
 export declare function assertNoSymlinkParents(params: AssertNoSymlinkParentsOptions): Promise<void>;
 export declare function assertNoSymlinkParentsSync(params: AssertNoSymlinkParentsOptions): void;
-//# sourceMappingURL=symlink-parents.d.ts.map

package/dist/symlink-parents.js

@@ -26,32 +26,7 @@ function formatUnsafePath(params, current) {
     return `${params.messagePrefix ?? "Path"} must not traverse symlinked directory: ${current}`;
 }
 export async function assertNoSymlinkParents(params) {
-    const walk = resolvePathWalk(params);
-    if (!walk) {
-        return;
-    }
-    let current = walk.root;
-    for (const [index, segment] of walk.segments.entries()) {
-        current = path.join(current, segment);
-        try {
-            const stat = fsSync.lstatSync(current);
-            if (stat.isSymbolicLink()) {
-                if (params.allowRootChildSymlink && path.dirname(current) === walk.root) {
-                    continue;
-                }
-                throw new Error(formatUnsafePath(params, current));
-            }
-            if ((params.requireDirectories || index < walk.segments.length - 1) && !stat.isDirectory()) {
-                throw new FsSafeError("not-file", `${params.messagePrefix ?? "Path"} must traverse directories: ${current}`);
-            }
-        }
-        catch (err) {
-            if (hasNodeErrorCode(err, "ENOENT") && params.allowMissing !== false) {
-                return;
-            }
-            throw err;
-        }
-    }
+    assertNoSymlinkParentsSync(params);
 }
 export function assertNoSymlinkParentsSync(params) {
     const walk = resolvePathWalk(params);
@@ -74,7 +49,7 @@ export function assertNoSymlinkParentsSync(params) {
             }
         }
         catch (err) {
-            if (err.code === "ENOENT" && params.allowMissing !== false) {
+            if (hasNodeErrorCode(err, "ENOENT") && params.allowMissing !== false) {
                 return;
             }
             throw err;

package/dist/temp-cleanup.d.ts

@@ -11,4 +11,3 @@ export declare function registerTempPathForExit(tempPath: string, options?: {
 }): TempPathRegistration;
 export declare function __cleanupRegisteredTempPathsForTest(): void;
 export declare function __cleanupRegisteredTempPathForTest(tempPath: string): void;
-//# sourceMappingURL=temp-cleanup.d.ts.map

package/dist/temp-target.d.ts

@@ -29,4 +29,3 @@ export declare function createOwnedTempFile(params: TempFileOptions): Promise<{
 export declare function tempFile(params: TempFileOptions): Promise<TempFile>;
 export declare function withTempFile<T>(params: TempFileOptions, fn: (tmpPath: string) => Promise<T>): Promise<T>;
 export {};
-//# sourceMappingURL=temp-target.d.ts.map

package/dist/temp-target.js

@@ -59,10 +59,7 @@ function sanitizeExtension(extension) {
     return token ? `.${token}` : "";
 }
 export function sanitizeTempFileName(fileName) {
-    const sanitized = sanitizeSafePathSegment(path.basename(fileName), "download.bin", {
-        allowDotPrefix: true,
-    });
-    return suffixWindowsReservedDeviceName(sanitized);
+    return suffixWindowsReservedDeviceName(sanitizeSafePathSegment(path.basename(fileName)) ?? "download.bin");
 }
 export function buildRandomTempFilePath(params) {
     const rootDir = resolveTempRoot(params.rootDir);
@@ -87,16 +84,7 @@ function isNodeErrorWithCode(err, code) {
 }
 async function cleanupTempDir(dir, identity, onCleanupError) {
     try {
-        let current;
-        try {
-            current = fsSync.lstatSync(dir, { bigint: true });
-        }
-        catch (error) {
-            if (isNodeErrorWithCode(error, "ENOENT")) {
-                return;
-            }
-            throw error;
-        }
+        const current = fsSync.lstatSync(dir, { bigint: true });
         if (!current || !sameFileIdentityForCleanup(current, identity)) {
             return;
         }
@@ -131,7 +119,7 @@ export async function createOwnedTempFile(params) {
     const prefix = `${sanitizePrefix(params.prefix)}-`;
     if (cleanupSafety === "require-bounded") {
         const initialFileName = sanitizeTempFileName(params.fileName ?? "download.bin");
-        const [{ TempWorkspaceCleanupCapability, TempWorkspaceCleanupOwner }, { admitExistingTempWorkspaceRoot }, { TempWorkspaceRetainedChild }, { validateInitialTempWorkspaceChild, admitRetainedTempWorkspaceChild }, { inspectDirectoryIdentitySync },] = await Promise.all([
+        const [{ TempWorkspaceCleanupCapability, TempWorkspaceCleanupOwner, throwTempWorkspaceCreationFailure }, { admitExistingTempWorkspaceRoot }, { TempWorkspaceRetainedChild }, { validateInitialTempWorkspaceChild }, { inspectDirectoryIdentitySync },] = await Promise.all([
             import("./temp-workspace-owner.js"),
             import("./temp-workspace-admission.js"),
             import("./temp-workspace-descriptor.js"),
@@ -159,9 +147,9 @@ export async function createOwnedTempFile(params) {
             identity = Object.freeze({ dev: initial.dev, ino: initial.ino });
             const needsModeInitialization = validateInitialTempWorkspaceChild(initial, admission.ownerUid, 0o700);
             retainedChild = TempWorkspaceRetainedChild.retain(dir, identity);
-            const modeInitialization = admitRetainedTempWorkspaceChild(retainedChild, needsModeInitialization, admission, 0o700);
-            if (modeInitialization)
-                await modeInitialization;
+            if (needsModeInitialization) {
+                await retainedChild.initializeMode(0o700, admission.ownerUid, admission.assertCurrent);
+            }
             const retainDescriptor = capability.admitChildDescriptor(retainedChild.ensureReadable());
             capability.assertAncestryCurrent();
             retainedChild.finalizeAdmission(admission.ownerUid, 0o700);
@@ -172,34 +160,7 @@ export async function createOwnedTempFile(params) {
             });
         }
         catch (error) {
-            try {
-                if (cleanupOwner)
-                    cleanupOwner.cleanupSync();
-                else {
-                    const closeErrors = [];
-                    try {
-                        retainedChild?.close();
-                    }
-                    catch (closeError) {
-                        closeErrors.push(closeError);
-                    }
-                    try {
-                        capability.close();
-                    }
-                    catch (closeError) {
-                        closeErrors.push(closeError);
-                    }
-                    if (closeErrors.length === 1)
-                        throw closeErrors[0];
-                    if (closeErrors.length > 1) {
-                        throw new AggregateError(closeErrors, "temp file admission descriptor close failed");
-                    }
-                }
-            }
-            catch (cleanupError) {
-                throw new AggregateError([error, cleanupError], "temp file creation and cleanup both failed");
-            }
-            throw error;
+            return throwTempWorkspaceCreationFailure(error, retainedChild, capability, cleanupOwner, "temp file");
         }
         const owner = cleanupOwner;
         const file = (fileName) => {

package/dist/temp-workspace-admission.d.ts

@@ -1,12 +1,6 @@
-type ExactIdentity = Readonly<{
-    dev: bigint;
-    ino: bigint;
-}>;
 export type TempWorkspaceRootAdmission = {
     dir: string;
-    identity: ExactIdentity;
     ownerUid: number | undefined;
-    realPath: string;
     retainCleanupParent(descriptorFd: number): void;
     prepareCleanupProbe(descriptorFd: number): void;
     prepareChildCreation(descriptorFd?: number): void;
@@ -18,5 +12,3 @@ export type TempWorkspaceRootAdmission = {
 export declare function admitExistingTempWorkspaceRoot(rootDir: string): TempWorkspaceRootAdmission;
 export declare function admitTempWorkspaceRoot(rootDir: string): Promise<TempWorkspaceRootAdmission>;
 export declare function admitTempWorkspaceRootSync(rootDir: string): TempWorkspaceRootAdmission;
-export {};
-//# sourceMappingURL=temp-workspace-admission.d.ts.map

package/dist/temp-workspace-admission.js

@@ -247,9 +247,7 @@ function rootAdmission(chain, ownerUid) {
     const current = chain[chain.length - 1];
     return {
         dir: current.dir,
-        identity: current.identity,
         ownerUid,
-        realPath: current.realPath,
         retainCleanupParent: (descriptorFd) => {
             assertSnapshot(current, ownerUid);
             associateTempWorkspaceRoot(current, ownerUid, descriptorFd);
@@ -280,9 +278,7 @@ function canonicalRootAdmission(discovery, ownerUid) {
     };
     return {
         dir: discovery.dir,
-        identity: discovery.identity,
         ownerUid,
-        realPath: discovery.realPath,
         // Merely opening the cleanup-parent descriptor grants no authority. The
         // exact association is completed only at a bounded probe or the mutation
         // boundary below.

package/dist/temp-workspace-child-admission.d.ts

@@ -1,13 +1,9 @@
 import type { BigIntStats, Stats } from "node:fs";
 import type { TempWorkspaceRootAdmission } from "./temp-workspace-admission.js";
-import type { TempWorkspaceRetainedChild } from "./temp-workspace-descriptor.js";
 import { type TempWorkspaceIdentityStat } from "./temp-workspace-identity.js";
 export declare function assertTempWorkspaceChildState(stat: BigIntStats | Stats, ownerUid: number | undefined): void;
 export declare function validateInitialTempWorkspaceChild(stat: BigIntStats, ownerUid: number | undefined, mode: number): boolean;
 export declare function childHasRequestedMode(stat: BigIntStats | Stats, mode: number): boolean;
 export declare function admitTempWorkspaceChild(dir: string, expected: BigIntStats, parent: TempWorkspaceRootAdmission, mode: number): Promise<void> | undefined;
 export declare function admitTempWorkspaceChildSync(dir: string, expected: BigIntStats, parent: TempWorkspaceRootAdmission, mode: number): void;
-export declare function admitRetainedTempWorkspaceChild(retained: TempWorkspaceRetainedChild, needsModeInitialization: boolean, parent: TempWorkspaceRootAdmission, mode: number): Promise<void> | undefined;
-export declare function admitRetainedTempWorkspaceChildSync(retained: TempWorkspaceRetainedChild, needsModeInitialization: boolean, parent: TempWorkspaceRootAdmission, mode: number): void;
 export declare function validateAdmittedTempWorkspaceChild(current: TempWorkspaceIdentityStat, ownerUid: number | undefined, mode: number): TempWorkspaceIdentityStat;
-//# sourceMappingURL=temp-workspace-child-admission.d.ts.map

package/dist/temp-workspace-child-admission.js

@@ -74,18 +74,6 @@ export function admitTempWorkspaceChildSync(dir, expected, parent, mode) {
         owner.close();
     }
 }
-export function admitRetainedTempWorkspaceChild(retained, needsModeInitialization, parent, mode) {
-    if (!needsModeInitialization)
-        return undefined;
-    return retained.initializeMode(mode, parent.ownerUid, parent.assertCurrent);
-}
-export function admitRetainedTempWorkspaceChildSync(retained, needsModeInitialization, parent, mode) {
-    if (!needsModeInitialization) {
-        retained.discardInitialReceipt();
-        return;
-    }
-    retained.initializeModeSync(mode, parent.ownerUid, parent.assertCurrent);
-}
 export function validateAdmittedTempWorkspaceChild(current, ownerUid, mode) {
     assertTempWorkspaceChildState(current, ownerUid);
     if (!childHasRequestedMode(current, mode)) {

package/dist/temp-workspace-descriptor.d.ts

@@ -8,11 +8,6 @@ export type RetainedDirectory = {
     access: DirectoryDescriptorAccess;
     receipt: Readonly<{
         path: string;
-        realPath: string;
-        identity: Readonly<{
-            dev: bigint;
-            ino: bigint;
-        }>;
     }>;
 };
 export type RetainedChildDirectory = {
@@ -45,4 +40,3 @@ export declare class TempWorkspaceRetainedChild {
     close(): void;
 }
 export {};
-//# sourceMappingURL=temp-workspace-descriptor.d.ts.map

package/dist/temp-workspace-descriptor.js

@@ -80,8 +80,6 @@ export function openTempWorkspaceCleanupParent(root, admission) {
             access: opened.access,
             receipt: Object.freeze({
                 path: pathname,
-                realPath: admission.realPath,
-                identity: admission.identity,
             }),
         };
     }

package/dist/temp-workspace-identity.d.ts

@@ -12,4 +12,3 @@ export declare const TEMP_WORKSPACE_NUMERIC_IDENTITY_REPLAY: boolean;
 export declare function projectTempWorkspaceNumericIdentity(identity: TempWorkspaceIdentity): TempWorkspaceNumericIdentity | undefined;
 export declare function inspectTempWorkspaceDescriptorIdentitySync(fd: number, expected: TempWorkspaceIdentity, numeric: TempWorkspaceNumericIdentity | undefined): TempWorkspaceIdentityStat;
 export declare function inspectTempWorkspaceDirectoryIdentitySync(dir: string, expected: TempWorkspaceIdentity, numeric: TempWorkspaceNumericIdentity | undefined): TempWorkspaceIdentityStat;
-//# sourceMappingURL=temp-workspace-identity.d.ts.map

package/dist/temp-workspace-owner.d.ts

@@ -15,10 +15,10 @@ export declare class TempWorkspaceCleanupCapability {
     assertAncestryCurrent(): void;
     close(): void;
 }
+export declare function throwTempWorkspaceCreationFailure(error: unknown, retainedChild: TempWorkspaceRetainedChild | undefined, capability: TempWorkspaceCleanupCapability, owner?: TempWorkspaceCleanupOwner, label?: string): never;
 export declare class TempWorkspaceCleanupOwner {
     #private;
     constructor(retained: TempWorkspaceRetainedChild, capability: TempWorkspaceCleanupCapability, retainDescriptor: boolean);
     cleanup(): Promise<TempWorkspaceCleanupResult>;
     cleanupSync(): TempWorkspaceCleanupResult;
 }
-//# sourceMappingURL=temp-workspace-owner.d.ts.map

package/dist/temp-workspace-owner.js

@@ -58,10 +58,10 @@ export class TempWorkspaceCleanupCapability {
         try {
             parent = openTempWorkspaceCleanupParent(root, admission);
         }
-        catch {
-            if (parent)
-                fsSync.closeSync(parent.fd);
-            parent = undefined;
+        catch (error) {
+            // Failed descriptor closure must retain the original admission failure too.
+            if (error instanceof AggregateError)
+                throw error;
         }
         let available = false;
         if (childModeAllowsRemoval && parent?.access === "read" && isNativeCleanupBinding(binding)) {
@@ -158,6 +158,36 @@ export class TempWorkspaceCleanupCapability {
             fsSync.closeSync(this.parent.fd);
     }
 }
+export function throwTempWorkspaceCreationFailure(error, retainedChild, capability, owner, label = "temp workspace") {
+    try {
+        if (owner)
+            owner.cleanupSync();
+        else {
+            const closeErrors = [];
+            try {
+                retainedChild?.close();
+            }
+            catch (closeError) {
+                closeErrors.push(closeError);
+            }
+            try {
+                capability.close();
+            }
+            catch (closeError) {
+                closeErrors.push(closeError);
+            }
+            if (closeErrors.length === 1)
+                throw closeErrors[0];
+            if (closeErrors.length > 1) {
+                throw new AggregateError(closeErrors, `${label} admission descriptor close failed`);
+            }
+        }
+    }
+    catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], `${label} creation and cleanup both failed`);
+    }
+    throw error;
+}
 export class TempWorkspaceCleanupOwner {
     #dir;
     #identity;
@@ -294,22 +324,19 @@ export class TempWorkspaceCleanupOwner {
                 await beforeNativeRemoval(quarantine.path);
             return this.#mapRemoval(await this.#capability.binding.removeOwnedTree(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalFailure;
         try {
             this.#assertQuarantine(quarantine);
-            try {
-                await fs.rm(quarantine.path, { recursive: true, force: true });
-            }
-            catch (error) {
-                removalFailure = { error };
-                throw error;
-            }
+        }
+        catch {
+            return "indeterminate";
+        }
+        // Removal failures propagate unchanged; only authority uncertainty becomes a receipt.
+        await fs.rm(quarantine.path, { recursive: true, force: true });
+        try {
             this.#capability.assertCurrent();
             return "removed";
         }
-        catch (error) {
-            if (removalFailure !== undefined)
-                throw removalFailure.error;
+        catch {
             return "indeterminate";
         }
     }
@@ -318,22 +345,18 @@ export class TempWorkspaceCleanupOwner {
             getFsSafeTestHooks()?.beforeTempWorkspaceNativeRemovalSync?.(quarantine.path);
             return this.#mapRemoval(this.#capability.binding.removeOwnedTreeSync(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalFailure;
         try {
             this.#assertQuarantine(quarantine);
-            try {
-                fsSync.rmSync(quarantine.path, { recursive: true, force: true });
-            }
-            catch (error) {
-                removalFailure = { error };
-                throw error;
-            }
+        }
+        catch {
+            return "indeterminate";
+        }
+        fsSync.rmSync(quarantine.path, { recursive: true, force: true });
+        try {
             this.#capability.assertCurrent();
             return "removed";
         }
-        catch (error) {
-            if (removalFailure !== undefined)
-                throw removalFailure.error;
+        catch {
             return "indeterminate";
         }
     }

package/dist/temp-workspace-permissions.d.ts

@@ -1,4 +1,3 @@
 import type { BigIntStats, Stats } from "node:fs";
 export declare function validateTempWorkspaceDirMode(mode: number): void;
 export declare function assertTrustedTempWorkspaceDirectory(stat: Pick<BigIntStats, "uid" | "mode"> | Pick<Stats, "uid" | "mode">, uid: number | undefined, child?: boolean): void;
-//# sourceMappingURL=temp-workspace-permissions.d.ts.map

package/dist/temp-workspace-types.d.ts

@@ -37,4 +37,3 @@ export type TempWorkspaceSync = {
     cleanup(): TempWorkspaceCleanupResult;
     [Symbol.dispose](): void;
 };
-//# sourceMappingURL=temp-workspace-types.d.ts.map

package/dist/temp.d.ts

@@ -1,4 +1,3 @@
 export { tempWorkspace, type TempWorkspace, type TempWorkspaceOptions, type TempWorkspaceCleanupResult, type TempWorkspaceCleanupSafety, tempWorkspaceSync, type TempWorkspaceSync, withTempWorkspace, withTempWorkspaceSync, } from "./private-temp-workspace.js";
 export type { TempPathIdentityReceipt } from "./temp-cleanup.js";
 export { resolveSecureTempRoot, type ResolveSecureTempRootOptions, type SecureTempRootDescriptorAdapter, } from "./secure-temp-dir.js";
-//# sourceMappingURL=temp.d.ts.map

package/dist/test-hooks.d.ts

@@ -29,4 +29,3 @@ export type FsSafeTestHooks = {
 };
 export declare function getFsSafeTestHooks(): FsSafeTestHooks | undefined;
 export declare function __setFsSafeTestHooksForTest(hooks?: FsSafeTestHooks): void;
-//# sourceMappingURL=test-hooks.d.ts.map

package/dist/text-atomic.d.ts

@@ -11,4 +11,3 @@ export type WriteTextAtomicOptions = {
     durable?: boolean;
 };
 export declare function writeTextAtomic(filePath: string, content: string, options?: WriteTextAtomicOptions): Promise<void>;
-//# sourceMappingURL=text-atomic.d.ts.map

package/dist/timing.d.ts

@@ -6,4 +6,3 @@ export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, l
     message?: string;
     createError?: () => Error;
 }): Promise<T>;
-//# sourceMappingURL=timing.d.ts.map

package/dist/trash.d.ts

@@ -2,4 +2,3 @@ export type MovePathToTrashOptions = {
     allowedRoots?: Iterable<string>;
 };
 export declare function movePathToTrash(targetPath: string, options?: MovePathToTrashOptions): Promise<string>;
-//# sourceMappingURL=trash.d.ts.map

package/dist/types.d.ts

@@ -20,4 +20,3 @@ export type BasePathOptions = {
     rootDir: string;
     relativePath: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/unicode-path.d.ts

@@ -1,3 +1,2 @@
 export declare function lowerCaseNfc(value: string): string;
 export declare function maxNormalizedUtf8Bytes(value: string, includeRaw?: boolean): number;
-//# sourceMappingURL=unicode-path.d.ts.map

package/dist/unicode-path.js

@@ -3,6 +3,9 @@ export function lowerCaseNfc(value) {
     return NON_ASCII.test(value) ? value.normalize("NFC").toLowerCase().normalize("NFC") : value.toLowerCase();
 }
 export function maxNormalizedUtf8Bytes(value, includeRaw = false) {
+    // ASCII has identical raw, NFC and NFD forms, with one UTF-8 byte per unit.
+    if (typeof value === "string" && !NON_ASCII.test(value))
+        return value.length;
     const nfc = value.normalize("NFC");
     const bytes = Buffer.byteLength(nfc, "utf8");
     const maximum = includeRaw && nfc !== value ? Math.max(bytes, Buffer.byteLength(value, "utf8")) : bytes;

package/dist/walk.d.ts

@@ -38,4 +38,3 @@ type WalkDirectoryResultWithFailures = WalkDirectoryResult & {
 export declare function walkDirectorySync(rootDir: string, options?: WalkDirectoryOptions): WalkDirectoryResultWithFailures;
 export declare function walkDirectory(rootDir: string, options?: AsyncWalkDirectoryOptions): Promise<WalkDirectoryResultWithFailures>;
 export {};
-//# sourceMappingURL=walk.d.ts.map

package/dist/walk.js

@@ -108,13 +108,14 @@ export function walkDirectorySync(rootDir, options = {}) {
             recordFailedDir(result, root, dir, depth, error);
             return;
         }
+        const childPrefix = dir.endsWith(path.sep) ? dir : `${dir}${path.sep}`;
         for (const dirent of entries) {
             if (shouldStop(result, options)) {
                 result.truncated = true;
                 return;
             }
             result.scannedEntryCount += 1;
-            const fullPath = path.join(dir, dirent.name);
+            const fullPath = childPrefix + dirent.name;
             const kind = resolveKind(fullPath, dirent, symlinks);
             if (!kind)
                 continue;
@@ -171,13 +172,14 @@ export async function walkDirectory(rootDir, options = {}) {
             recordFailedDir(result, root, dir, depth, error);
             return;
         }
+        const childPrefix = dir.endsWith(path.sep) ? dir : `${dir}${path.sep}`;
         for (const dirent of entries) {
             if (shouldStop(result, options)) {
                 result.truncated = true;
                 return;
             }
             result.scannedEntryCount += 1;
-            const fullPath = path.join(dir, dirent.name);
+            const fullPath = childPrefix + dirent.name;
             const kind = resolveKind(fullPath, dirent, symlinks);
             if (!kind)
                 continue;

package/dist/windows-command.d.ts

@@ -1,2 +1 @@
 export declare function resolveWindowsSystemCommand(command: string, env?: NodeJS.ProcessEnv): string;
-//# sourceMappingURL=windows-command.d.ts.map

package/dist/windows-owner.d.ts

@@ -26,4 +26,3 @@ export declare function inspectWindowsOwner(params: {
     env?: NodeJS.ProcessEnv;
     exec: WindowsOwnerExec;
 }): Promise<WindowsOwnerSummary>;
-//# sourceMappingURL=windows-owner.d.ts.map

package/dist/windows-owner.js

@@ -79,7 +79,10 @@ export async function inspectWindowsOwner(params) {
         if (!ownerSid || !currentUserSid) {
             return { error: "Windows owner query returned invalid SID data" };
         }
-        const remote = parsed.remote === true;
+        const remote = parsed.remote;
+        if (typeof remote !== "boolean") {
+            return { error: "Windows owner query returned invalid locality data" };
+        }
         return {
             sid: ownerSid,
             currentUserSid,

package/dist/windows-path-alias.d.ts

@@ -36,4 +36,3 @@ export declare function hasWindowsPathAlias(value: string, kind: WindowsPathAlia
 export declare function assertNoWindowsPathAliasForPlatform(value: string, kind: WindowsPathAliasKind, message: string, platform: NodeJS.Platform | string | undefined): void;
 export declare function assertNoWindowsPathAlias(value: string, kind?: WindowsPathAliasKind, message?: string, platform?: NodeJS.Platform | string): void;
 export declare function isWindowsPathAliasError(error: unknown): error is FsSafeError;
-//# sourceMappingURL=windows-path-alias.d.ts.map