@openclaw/fs-safe 0.11.0 → 0.13.0

package/dist/secure-file-windows.js

@@ -0,0 +1,186 @@
+import { FsSafeError } from "./errors.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+import { getNativeBinding } from "./native.js";
+const IDENTITY_RE = /^([0-9a-f]{8}):([0-9a-f]{16})$/;
+const SID_RE = /^s-\d+-\d+(?:-\d+)+$/;
+const OWNER_CLASSES = new Set(["current-user", "system", "administrators", "foreign"]);
+const TRUSTED_OWNER_CLASSES = new Set(["current-user", "system", "administrators"]);
+const SYSTEM_SID = "s-1-5-18";
+const ADMINISTRATORS_SID = "s-1-5-32-544";
+const WORLD_SIDS = new Set([
+    "s-1-1-0", "s-1-5-11", "s-1-5-32-545", "s-1-5-7",
+    "s-1-5-32-546", "s-1-5-4", "s-1-5-2",
+]);
+const GENERIC_READ = 0x8000_0000;
+const GENERIC_WRITE = 0x4000_0000;
+const GENERIC_ALL = 0x1000_0000;
+const DELETE_ACCESS = 0x0001_0000;
+const WRITE_DAC = 0x0004_0000;
+const WRITE_OWNER = 0x0008_0000;
+const FILE_READ_DATA = 0x0000_0001;
+const FILE_WRITE_DATA = 0x0000_0002;
+const FILE_APPEND_DATA = 0x0000_0004;
+const FILE_READ_EA = 0x0000_0008;
+const FILE_WRITE_EA = 0x0000_0010;
+const FILE_DELETE_CHILD = 0x0000_0040;
+const FILE_READ_ATTRIBUTES = 0x0000_0080;
+const FILE_WRITE_ATTRIBUTES = 0x0000_0100;
+function permissionUnverified(message, cause) {
+    throw new FsSafeError("permission-unverified", message, cause === undefined ? {} : { cause });
+}
+function identityMismatch() {
+    const error = new FsSafeError("path-mismatch", "file identity changed or could not be verified");
+    recordFileObservationFailure(error, "identity");
+    throw error;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isUint32(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 0xffff_ffff;
+}
+function parseIdentity(value) {
+    if (typeof value !== "string")
+        identityMismatch();
+    const match = IDENTITY_RE.exec(value);
+    if (!match)
+        identityMismatch();
+    return {
+        dev: BigInt(`0x${match[1]}`),
+        ino: BigInt(`0x${match[2]}`),
+    };
+}
+function validateFlags(value) {
+    if (!isRecord(value))
+        return false;
+    const raw = value.raw;
+    if (!isUint32(raw) || (raw & ~0xdf) !== 0)
+        return false;
+    const fields = [
+        ["objectInherit", 0x01], ["containerInherit", 0x02],
+        ["noPropagateInherit", 0x04], ["inheritOnly", 0x08], ["inherited", 0x10],
+        ["successfulAccess", 0x40], ["failedAccess", 0x80],
+    ];
+    return fields.every(([field, bit]) => typeof value[field] === "boolean" && value[field] === ((raw & bit) !== 0));
+}
+function validateAce(value) {
+    return isRecord(value) && typeof value.sid === "string" && SID_RE.test(value.sid) &&
+        isUint32(value.mask) && (value.aceType === "allow" || value.aceType === "deny") &&
+        validateFlags(value.flags);
+}
+function canRead(mask) {
+    return (mask & (GENERIC_ALL | GENERIC_READ | FILE_READ_DATA | FILE_READ_EA |
+        FILE_READ_ATTRIBUTES)) !== 0;
+}
+function canWrite(mask) {
+    return (mask & (GENERIC_ALL | GENERIC_WRITE | FILE_WRITE_DATA | FILE_APPEND_DATA |
+        FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES | FILE_DELETE_CHILD | DELETE_ACCESS |
+        WRITE_DAC | WRITE_OWNER)) !== 0;
+}
+function expectedOwnerClass(facts) {
+    if (facts.ownerSid === facts.currentUserSid)
+        return "current-user";
+    if (facts.ownerSid === SYSTEM_SID)
+        return "system";
+    if (facts.ownerSid === ADMINISTRATORS_SID)
+        return "administrators";
+    return "foreign";
+}
+function validateSecurity(value) {
+    if (!isRecord(value))
+        permissionUnverified("Windows descriptor ACL facts were malformed");
+    const facts = value;
+    const booleans = [
+        "worldWritable", "groupWritable", "worldReadable", "groupReadable",
+        "fallbackRequired", "daclPresent", "isLocal", "aceListComplete",
+    ];
+    if (!booleans.every((field) => typeof facts[field] === "boolean") ||
+        typeof facts.ownerSid !== "string" || !SID_RE.test(facts.ownerSid) ||
+        typeof facts.currentUserSid !== "string" || !SID_RE.test(facts.currentUserSid) ||
+        typeof facts.ownerClass !== "string" || !OWNER_CLASSES.has(facts.ownerClass) ||
+        !Array.isArray(facts.unsupportedAceTypes) ||
+        !facts.unsupportedAceTypes.every(isUint32) ||
+        !Array.isArray(facts.aces) || !facts.aces.every(validateAce)) {
+        permissionUnverified("Windows descriptor ACL facts were malformed");
+    }
+    if (facts.ownerClass !== expectedOwnerClass(facts)) {
+        permissionUnverified("Windows descriptor owner facts were inconsistent");
+    }
+    if (facts.fallbackRequired || !facts.isLocal || !facts.aceListComplete ||
+        facts.unsupportedAceTypes.length !== 0) {
+        permissionUnverified("Windows descriptor ACL facts were incomplete or unsupported");
+    }
+    if (!facts.daclPresent && facts.aces.length !== 0) {
+        permissionUnverified("Windows descriptor DACL facts were inconsistent");
+    }
+    return facts;
+}
+function validatePermissionSummary(facts) {
+    let worldReadable = !facts.daclPresent;
+    let worldWritable = !facts.daclPresent;
+    let groupReadable = false;
+    let groupWritable = false;
+    const trustedSids = new Set([facts.currentUserSid, SYSTEM_SID, ADMINISTRATORS_SID]);
+    for (const ace of facts.aces) {
+        if (ace.aceType !== "allow" || ace.flags.inheritOnly || trustedSids.has(ace.sid))
+            continue;
+        const world = WORLD_SIDS.has(ace.sid);
+        if (world) {
+            worldReadable ||= canRead(ace.mask);
+            worldWritable ||= canWrite(ace.mask);
+        }
+        else {
+            groupReadable ||= canRead(ace.mask);
+            groupWritable ||= canWrite(ace.mask);
+        }
+    }
+    if (facts.worldReadable !== worldReadable || facts.worldWritable !== worldWritable ||
+        facts.groupReadable !== groupReadable || facts.groupWritable !== groupWritable) {
+        permissionUnverified("Windows descriptor ACL summary was inconsistent");
+    }
+}
+export function inspectSecureWindowsDescriptor(params) {
+    let native;
+    try {
+        native = getNativeBinding();
+    }
+    catch (cause) {
+        permissionUnverified("Windows descriptor ACL verification requires the matching native helper", cause);
+    }
+    const inspect = native?.inspectWindowsSecureFileHandle;
+    if (typeof inspect !== "function") {
+        permissionUnverified("Windows descriptor ACL verification requires an up-to-date native helper");
+    }
+    let result;
+    try {
+        result = inspect.call(native, params.fd);
+    }
+    catch (cause) {
+        permissionUnverified("Windows descriptor ACL verification failed", cause);
+    }
+    if (!isRecord(result))
+        permissionUnverified("Windows descriptor ACL facts were malformed");
+    const observed = parseIdentity(result.identity);
+    if (observed.dev !== params.identity.dev || observed.ino !== params.identity.ino) {
+        identityMismatch();
+    }
+    const facts = validateSecurity(result.security);
+    validatePermissionSummary(facts);
+    return {
+        ok: true,
+        isSymlink: false,
+        isDir: params.stat.isDirectory(),
+        mode: typeof params.stat.mode === "number" ? params.stat.mode : null,
+        bits: null,
+        source: "windows-acl",
+        worldWritable: facts.worldWritable,
+        groupWritable: facts.groupWritable,
+        worldReadable: facts.worldReadable,
+        groupReadable: facts.groupReadable,
+        ownerSid: facts.ownerSid,
+        ownerTrusted: TRUSTED_OWNER_CLASSES.has(facts.ownerClass),
+        aclSummary: `native descriptor owner=${facts.ownerClass} world=` +
+            `${facts.worldReadable ? "r" : "-"}${facts.worldWritable ? "w" : "-"} ` +
+            `group=${facts.groupReadable ? "r" : "-"}${facts.groupWritable ? "w" : "-"}`,
+    };
+}

package/dist/secure-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secure-file.d.ts","sourceRoot":"","sources":["../src/secure-file.ts"],"names":[],"mappings":"AAAA,OAAe,EAAoB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAc/D,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAI1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,sBAAsB,CAAC;IAC/B,WAAW,CAAC,EAAE,2BAA2B,CAAC;IAC1C,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,EAAE,CAAC,EAAE,mBAAmB,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AAmNF,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAuB/B"}
+{"version":3,"file":"secure-file.d.ts","sourceRoot":"","sources":["../src/secure-file.ts"],"names":[],"mappings":"AAAA,OAAe,EAAoB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAe/D,OAAO,EAOL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAU1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,sBAAsB,CAAC;IAC/B,WAAW,CAAC,EAAE,2BAA2B,CAAC;IAC1C,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,EAAE,CAAC,EAAE,mBAAmB,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,CAAC;AAgTF,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CAgC/B"}

package/dist/secure-file.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { readFileHandleBounded } from "./bounded-read.js";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { assertNoUnsafeDeviceReadPath } from "./device-path.js";
+import { resolveEffectiveUid } from "./effective-uid.js";
 import { FsSafeError } from "./errors.js";
 import { isWindowsDriveLetterPath, isWindowsNetworkPath } from "./local-file-access.js";
 import { isPathInside, isSymlinkOpenError } from "./path.js";
@@ -12,7 +13,77 @@ import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { realpathSync } from "./realpath.js";
 import { inspectPathPermissions, isGroupReadable, isGroupWritable, isWorldReadable, isWorldWritable, modeBits, } from "./permissions.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
+import { inspectSecureWindowsDescriptor } from "./secure-file-windows.js";
 import { scheduleTimeout } from "./timing.js";
+import { anchorWindowsDriveRelativePath, assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+function snapshotTrustedDirs(dirs) {
+    if (dirs === undefined)
+        return undefined;
+    if (!Array.isArray(dirs)) {
+        throw new FsSafeError("invalid-path", "trustedDirs must be an array of path strings.");
+    }
+    const trustedDirs = [];
+    const length = dirs.length;
+    if (!Number.isSafeInteger(length) || length < 0 || length > 0xffff_ffff) {
+        throw new FsSafeError("invalid-path", "trustedDirs must have a valid array length.");
+    }
+    for (let index = 0; index < length; index += 1) {
+        if (!Object.hasOwn(dirs, index)) {
+            throw new FsSafeError("invalid-path", "trustedDirs must not contain sparse entries.");
+        }
+        const dir = dirs[index];
+        if (typeof dir !== "string" || dir.includes("\0")) {
+            throw new FsSafeError("invalid-path", "trustedDirs must contain only path strings without null bytes.");
+        }
+        // Admit the raw suffix before normalization can erase an alternate stream,
+        // while retaining Node's per-drive cwd semantics for D:credentials.
+        const anchored = anchorWindowsDriveRelativePath(dir);
+        assertNoWindowsPathAlias(anchored, "filesystem", "trusted directory uses a Windows filesystem namespace alias");
+        const resolved = resolvePathPreservingWindowsRoot(anchored);
+        assertNoWindowsPathAlias(resolved, "filesystem", "trusted directory uses a Windows filesystem namespace alias");
+        trustedDirs.push(resolved);
+    }
+    return trustedDirs;
+}
+function snapshotPermissionEnv(env) {
+    if (env === undefined)
+        return undefined;
+    const snapshot = { ...env };
+    // Windows command lookup first reads these exact names, even when inherited
+    // or non-enumerable, then considers only enumerable own case variants.
+    // Reuse copied values so enumerable getters are not invoked a second time.
+    if (!Object.hasOwn(snapshot, "SystemRoot"))
+        snapshot.SystemRoot = env.SystemRoot;
+    if (!Object.hasOwn(snapshot, "WINDIR"))
+        snapshot.WINDIR = env.WINDIR;
+    return snapshot;
+}
+function snapshotSecureFileOptions(options, io, maxBytes) {
+    const { filePath, label, trust, permissions, inject } = options;
+    const env = inject?.env;
+    return {
+        filePath,
+        label,
+        trust: {
+            trustedDirs: snapshotTrustedDirs(trust?.trustedDirs),
+            allowSymlink: trust?.allowSymlink,
+            allowNetworkPath: trust?.allowNetworkPath,
+        },
+        permissions: {
+            allowInsecure: permissions?.allowInsecure,
+            allowReadableByOthers: permissions?.allowReadableByOthers,
+        },
+        inject: {
+            platform: inject?.platform,
+            env: snapshotPermissionEnv(env),
+            exec: inject?.exec,
+        },
+        io: {
+            maxBytes,
+            timeoutMs: io?.timeoutMs,
+        },
+    };
+}
 function isAbsolutePathname(value) {
     return (path.isAbsolute(value) ||
         (process.platform === "win32" &&
@@ -81,6 +152,7 @@ async function openSecureHandle(options, maxBytes) {
             return pathStat;
         }, openedIdentity);
         const realPath = realpathSync.native(options.filePath);
+        assertNoWindowsPathAlias(realPath, "filesystem", `${label(options)} resolved path uses a Windows filesystem namespace alias`);
         await inspectFileIdentity(() => {
             const realPathStat = fsSync.statSync(realPath, { bigint: true });
             assertNotHardlinked(options, realPathStat);
@@ -101,13 +173,15 @@ async function assertTrustedDirs(options, realPath) {
         return;
     }
     const trusted = await Promise.all(options.trust.trustedDirs.map(async (dir) => {
-        const resolved = path.resolve(dir);
+        let realPath;
         try {
-            return realpathSync.native(resolved);
+            realPath = realpathSync.native(dir);
         }
         catch {
-            return resolved;
+            return dir;
         }
+        assertNoWindowsPathAlias(realPath, "filesystem", "trusted directory uses a Windows filesystem namespace alias");
+        return realPath;
     }));
     if (!trusted.some((dir) => isPathInside(dir, realPath))) {
         throw new FsSafeError("outside-workspace", `${label(options)} is outside trustedDirs: ${realPath}`);
@@ -128,13 +202,15 @@ function inspectOpenedPermissions(stat, platform) {
         groupReadable: isGroupReadable(bits),
     };
 }
-async function assertSecurePermissions(options, stat, realPath) {
+async function assertSecurePermissions(options, stat, realPath, identity, fd) {
     if (options.permissions?.allowInsecure) {
         return undefined;
     }
     const platform = options.inject?.platform ?? process.platform;
     const permissions = platform === "win32"
-        ? await inspectPathPermissions(realPath, options.inject)
+        ? process.platform === "win32"
+            ? inspectSecureWindowsDescriptor({ fd, identity, stat })
+            : await inspectPathPermissions(realPath, options.inject)
         : inspectOpenedPermissions(stat, platform);
     const reason = permissions.error ? `: ${formatPermissionErrorDetail(permissions.error)}` : "";
     const diagnostics = {
@@ -160,10 +236,19 @@ async function assertSecurePermissions(options, stat, realPath) {
     if (writableByOthers || (!options.permissions?.allowReadableByOthers && readableByOthers)) {
         throw new FsSafeError("insecure-permissions", `${label(options)} permissions are too open: ${realPath}`);
     }
-    if (platform !== "win32" && typeof process.getuid === "function" && stat.uid != null) {
-        const uid = process.getuid();
+    if (platform !== "win32") {
+        let uid;
+        try {
+            uid = resolveEffectiveUid();
+        }
+        catch (cause) {
+            throw new FsSafeError("permission-unverified", `${label(options)} owner identity could not be verified for the effective user: ${realPath}`, { cause });
+        }
+        if (uid === undefined || !Number.isSafeInteger(stat.uid) || stat.uid < 0) {
+            throw new FsSafeError("permission-unverified", `${label(options)} owner identity could not be verified for the effective user: ${realPath}`);
+        }
         if (stat.uid !== uid) {
-            throw new FsSafeError("not-owned", `${label(options)} must be owned by the current user (uid=${uid}): ${realPath}`);
+            throw new FsSafeError("not-owned", `${label(options)} must be owned by the effective user (uid=${uid}): ${realPath}`);
         }
     }
     return permissions;
@@ -190,11 +275,14 @@ async function readHandleWithTimeout(handle, timeoutMs, maxBytes) {
     }
 }
 export async function readSecureFile(options) {
-    const maxBytes = normalizeMaxBytes(options.io?.maxBytes);
+    const io = options.io;
+    const maxBytes = normalizeMaxBytes(io?.maxBytes);
+    options = snapshotSecureFileOptions(options, io, maxBytes);
+    assertNoWindowsPathAlias(options.filePath, "filesystem", `${label(options)} path uses a Windows filesystem namespace alias`);
     const opened = await openSecureHandle(options, maxBytes);
     try {
         await assertTrustedDirs(options, opened.realPath);
-        const permissions = await assertSecurePermissions(options, opened.pathStat, opened.realPath);
+        const permissions = await assertSecurePermissions(options, opened.pathStat, opened.realPath, opened.identity, opened.handle.fd);
         const buffer = await readHandleWithTimeout(opened.handle, options.io?.timeoutMs, maxBytes);
         const finalIdentity = await inspectFileIdentity(() => fsSync.fstatSync(opened.handle.fd, { bigint: true }), opened.identity);
         if (!finalIdentity.isFile()) {

package/dist/secure-temp-dir.d.ts

@@ -1,12 +1,16 @@
+import { type SecureTempRootDescriptorAdapter } from "./secure-temp-repair.js";
+export type { SecureTempRootDescriptorAdapter } from "./secure-temp-repair.js";
 type SecureDirStat = {
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
-    mode?: number;
-    uid?: number;
+    mode?: number | bigint;
+    uid?: number | bigint;
 };
 export type ResolveSecureTempRootOptions = {
     accessSync?: (path: string, mode?: number) => void;
+    /** @deprecated Unused. Repairs require descriptor-bound chmod. */
     chmodSync?: (path: string, mode: number) => void;
+    descriptor?: SecureTempRootDescriptorAdapter;
     fallbackPrefix: string;
     getuid?: () => number | undefined;
     lstatSync?: (path: string) => SecureDirStat;
@@ -23,5 +27,4 @@ export type ResolveSecureTempRootOptions = {
     warningPrefix?: string;
 };
 export declare function resolveSecureTempRoot(options: ResolveSecureTempRootOptions): string;
-export {};
 //# sourceMappingURL=secure-temp-dir.d.ts.map

package/dist/secure-temp-dir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secure-temp-dir.d.ts","sourceRoot":"","sources":["../src/secure-temp-dir.ts"],"names":[],"mappings":"AAQA,KAAK,aAAa,GAAG;IACnB,WAAW,IAAI,OAAO,CAAC;IACvB,cAAc,IAAI,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAWF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,MAAM,CA+JnF"}
+{"version":3,"file":"secure-temp-dir.d.ts","sourceRoot":"","sources":["../src/secure-temp-dir.ts"],"names":[],"mappings":"AAOA,OAAO,EAKL,KAAK,+BAA+B,EACrC,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAI/E,KAAK,aAAa,GAAG;IACnB,WAAW,IAAI,OAAO,CAAC;IACvB,cAAc,IAAI,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,kEAAkE;IAClE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,UAAU,CAAC,EAAE,+BAA+B,CAAC;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAClC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAWF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,MAAM,CA6LnF"}