@openclaw/fs-safe 0.14.0 → 0.16.0

package/dist/owner-dacl.js

@@ -1,17 +1,23 @@
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { warnNativeFallback } from "./native-fallback-warning.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { readWindowsSecurityFactsCommand } from "./windows-security-command.js";
 export function readOwnerAndDacl(targetPath) {
     if (process.platform !== "win32") {
         return { status: "unsupported-platform", platform: process.platform };
     }
     assertNoWindowsPathAlias(targetPath, "filesystem", "owner and DACL path uses a Windows filesystem namespace alias");
     const native = getNativeBinding();
-    if (!native) {
-        throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require the matching optional native platform package; " +
-            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    const inspect = native?.readOwnerAndDacl;
+    if (typeof inspect !== "function") {
+        if (getFsSafeNativeConfig().mode === "require") {
+            throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require an up-to-date native helper");
+        }
+        warnNativeFallback("windows-owner-dacl", "Windows owner and DACL inspection uses a slower built-in system command.");
     }
-    const facts = native.readOwnerAndDacl(targetPath);
+    const facts = typeof inspect === "function" ? inspect.call(native, targetPath) : readWindowsSecurityFactsCommand(targetPath);
     return {
         status: "supported",
         ownerSid: facts.ownerSid,

package/dist/path-prefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-prefix.d.ts","sourceRoot":"","sources":["../src/path-prefix.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAChD,CAAC;AAkBF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAsDvE"}
+{"version":3,"file":"path-prefix.d.ts","sourceRoot":"","sources":["../src/path-prefix.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAChD,CAAC;AAuBF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAuEvE"}

package/dist/path-prefix.js

@@ -19,15 +19,23 @@ function resolutionError(code, absolutePath) {
         code, syscall: "resolvePathPrefix", path: absolutePath,
     });
 }
+// Leave ample room for ordinary shallow paths to retain the legacy small-array
+// path. At 32 components, repeated front removal can reindex at most 496 array
+// positions per constructed queue; longer queues use a forward cursor instead.
+const SHIFT_QUEUE_COMPONENT_LIMIT = 32;
 export function resolvePathPrefixSync(input) {
     assertNoNulPathInput(input);
     const absolutePath = absolutePathWithRawSegments(input);
     let resolved = rawRoot(absolutePath);
-    const remaining = absolutePath.slice(resolved.length).split(path.sep);
+    let remaining = absolutePath.slice(resolved.length).split(path.sep);
+    let shiftQueue = remaining.length <= SHIFT_QUEUE_COMPONENT_LIMIT;
+    let nextSegment = 0;
+    let remainingCount = remaining.length;
     const visitedStates = new Set();
     let symlinkHops = 0;
-    while (remaining.length > 0) {
-        const segment = remaining.shift();
+    while (remainingCount > 0) {
+        const segment = shiftQueue ? remaining.shift() : remaining[nextSegment++];
+        remainingCount--;
         if (segment === "")
             continue;
         if (segment === "." || segment === "..") {
@@ -51,32 +59,46 @@ export function resolvePathPrefixSync(input) {
             return {
                 absolutePath,
                 existingPath: realpathSync.native(pathForWindowsFilesystem(resolved)),
-                unresolvedSegments: [segment, ...remaining],
+                unresolvedSegments: shiftQueue ? [segment, ...remaining] : remaining.slice(nextSegment - 1),
             };
         }
         if (!stat.isSymbolicLink()) {
-            if (!stat.isDirectory() && remaining.length > 0)
+            if (!stat.isDirectory() && remainingCount > 0)
                 throw resolutionError("ENOTDIR", absolutePath);
             resolved = candidate;
             continue;
         }
-        const state = JSON.stringify([String(stat.dev), String(stat.ino), candidate, remaining]);
+        const pendingSuffix = shiftQueue ? remaining : remaining.slice(nextSegment);
+        const state = JSON.stringify([String(stat.dev), String(stat.ino), candidate, pendingSuffix]);
         if (symlinkHops >= 64 || visitedStates.has(state))
             throw resolutionError("ELOOP", absolutePath);
         visitedStates.add(state);
         symlinkHops++;
         const target = fs.readlinkSync(candidate);
         const rawTarget = path.sep === "\\" ? target.replaceAll("/", "\\") : target;
+        let targetSegments;
         if (path.isAbsolute(rawTarget)) {
             const targetRoot = rawRoot(rawTarget);
             // A rooted Windows link target uses the link's drive/share, not cwd's.
             resolved = path.sep === "\\" && targetRoot === "\\" ? rawRoot(resolved) : targetRoot;
-            remaining.unshift(...rawTarget.slice(targetRoot.length).split(path.sep));
+            targetSegments = rawTarget.slice(targetRoot.length).split(path.sep);
         }
         else {
             // A target's parent traversal applies after resolving its preceding links.
-            remaining.unshift(...rawTarget.split(path.sep));
+            targetSegments = rawTarget.split(path.sep);
         }
+        const expandedCount = targetSegments.length + pendingSuffix.length;
+        if (expandedCount <= SHIFT_QUEUE_COMPONENT_LIMIT) {
+            // The spread is bounded by the same fixed limit as subsequent shifts.
+            remaining = pendingSuffix;
+            remaining.unshift(...targetSegments);
+        }
+        else {
+            remaining = targetSegments.concat(pendingSuffix);
+        }
+        remainingCount = remaining.length;
+        shiftQueue = remainingCount <= SHIFT_QUEUE_COMPONENT_LIMIT;
+        nextSegment = 0;
     }
     return { absolutePath, existingPath: realpathSync.native(pathForWindowsFilesystem(resolved)), unresolvedSegments: [] };
 }

package/dist/path-suffix-aliases.d.ts

@@ -2,6 +2,8 @@ export type ProbePathSuffixAliasesOptions = {
     directory: string;
     left: string;
     right: string;
+    /** Maximum relative component count; defaults to 32. */
+    maxDepth?: number;
     /** Synchronous caller policy for differing NFC pairs not equivalent under ASCII case folding. */
     shouldProbeCaseVariants?: (leftNfc: string, rightNfc: string) => boolean;
 };

package/dist/path-suffix-aliases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path-suffix-aliases.d.ts","sourceRoot":"","sources":["../src/path-suffix-aliases.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,iGAAiG;IACjG,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CAC1E,CAAC;AA6UF,4FAA4F;AAC5F,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,6BAA6B,GAAG,OAAO,GAAG,SAAS,CA8CtG"}
+{"version":3,"file":"path-suffix-aliases.d.ts","sourceRoot":"","sources":["../src/path-suffix-aliases.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CAC1E,CAAC;AAkVF,4FAA4F;AAC5F,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,6BAA6B,GAAG,OAAO,GAAG,SAAS,CAmDtG"}

package/dist/path-suffix-aliases.js

@@ -15,6 +15,7 @@ const MAX_SUFFIX_DEPTH = 32;
 const MAX_MKDIR_ATTEMPTS = 128;
 const MAX_CREATED_DIRECTORIES = 64;
 const MAX_FORWARD_OBSERVATIONS = 4_096;
+const MAX_SCALED_FORWARD_OBSERVATIONS = 32_768;
 const PROBE_NAME_LENGTH = 6;
 const PROBE_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 const PROBE_FIRST_ALPHABET = "bdefghijkmoqrstuvwxyz";
@@ -25,7 +26,7 @@ function assertMutationPath(value) {
     if (value.length > MAX_PATH_LENGTH)
         unavailable();
 }
-function suffixSegments(value) {
+function suffixSegments(value, maxDepth) {
     if (typeof value !== "string")
         throw new TypeError("suffix must be a string");
     if (value.length > MAX_SUFFIX_LENGTH)
@@ -35,8 +36,8 @@ function suffixSegments(value) {
     }
     const windows = process.platform === "win32";
     const segments = (windows ? value.replaceAll("/", "\\") : value).split(path.sep);
-    if (segments.length > MAX_SUFFIX_DEPTH)
-        throw new RangeError("suffix exceeds 32 components");
+    if (segments.length > maxDepth)
+        throw new RangeError(`suffix exceeds ${maxDepth} components`);
     if (segments.some(segment => !segment || segment === "." || segment === ".." ||
         (windows && (segment.includes(":") || /^[ .]+$/u.test(segment) ||
             isWindowsReservedDeviceName(segment))))) {
@@ -96,14 +97,8 @@ function createPrivateProbeName(nameLength) {
     return name;
 }
 function* asciiCaseProbePairs(nameLength, forbidden) {
-    let count = 0;
-    for (let attempt = 0; attempt < 96 && count < 24; attempt++) {
-        const first = createPrivateProbeName(nameLength);
-        const second = `${first[0].toUpperCase()}${first.slice(1)}`;
-        if (!forbidden(first) && !forbidden(second)) {
-            count++;
-            yield [first, second];
-        }
+    for (const first of privateProbeNames(nameLength, forbidden)) {
+        yield [first, `${first[0].toUpperCase()}${first.slice(1)}`];
     }
 }
 function* privateProbeNames(nameLength, forbidden) {
@@ -128,8 +123,16 @@ class ProbeDirectories {
     observations = 0;
     mkdirAttempts = 0;
     creations = 0;
-    constructor(requestedDirectory) {
+    maxObservations;
+    maxMkdirAttempts;
+    maxCreations;
+    constructor(requestedDirectory, depth) {
         this.requestedDirectory = requestedDirectory;
+        // The suffix-length limit bounds actual depth, so these products remain safe integers.
+        const scale = Math.max(1, depth / MAX_SUFFIX_DEPTH);
+        this.maxObservations = Math.min(MAX_SCALED_FORWARD_OBSERVATIONS, MAX_FORWARD_OBSERVATIONS * scale * scale);
+        this.maxMkdirAttempts = MAX_MKDIR_ATTEMPTS * scale;
+        this.maxCreations = MAX_CREATED_DIRECTORIES * scale;
         this.observe(1);
         const canonical = realpathSync.native(pathForWindowsFilesystem(requestedDirectory));
         assertMutationPath(canonical);
@@ -138,7 +141,7 @@ class ProbeDirectories {
         this.assert(this.root);
     }
     reserveObservations(units) {
-        if (this.observations + units > MAX_FORWARD_OBSERVATIONS)
+        if (units > this.maxObservations - this.observations)
             unavailable();
     }
     observe(units, cleanup = false) {
@@ -159,7 +162,7 @@ class ProbeDirectories {
         }
     }
     create(parent, name) {
-        if (this.mkdirAttempts >= MAX_MKDIR_ATTEMPTS || this.creations >= MAX_CREATED_DIRECTORIES)
+        if (this.mkdirAttempts >= this.maxMkdirAttempts || this.creations >= this.maxCreations)
             unavailable();
         const probePath = path.join(parent.path, name);
         assertMutationPath(probePath);
@@ -337,11 +340,16 @@ export function probePathSuffixAliasesSync(options) {
     const directory = resolvePathPreservingWindowsRoot(requestedDirectory);
     if (directory.length > MAX_PATH_LENGTH)
         throw new RangeError("resolved directory exceeds 32768 code units");
+    const requestedMaxDepth = options.maxDepth;
+    const maxDepth = requestedMaxDepth === undefined ? MAX_SUFFIX_DEPTH : requestedMaxDepth;
+    if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) {
+        throw new RangeError("maxDepth must be a non-negative safe integer");
+    }
     const leftInput = options.left;
     const rightInput = options.right;
     const predicate = options.shouldProbeCaseVariants;
-    const left = suffixSegments(leftInput);
-    const right = suffixSegments(rightInput);
+    const left = suffixSegments(leftInput, maxDepth);
+    const right = suffixSegments(rightInput, maxDepth);
     if (left.length !== right.length)
         throw new TypeError("suffixes must have the same component count");
     if (predicate !== undefined && typeof predicate !== "function") {
@@ -370,7 +378,7 @@ export function probePathSuffixAliasesSync(options) {
     let observed;
     let cleaned = true;
     try {
-        observed = observeSuffixes(() => owner ??= new ProbeDirectories(directory), left, right, shouldProbe);
+        observed = observeSuffixes(() => owner ??= new ProbeDirectories(directory, left.length), left, right, shouldProbe);
         owner?.assert(owner.root);
     }
     catch {

package/dist/permission-exec.d.ts

@@ -8,6 +8,8 @@ export type PermissionCommandFailure = {
     stderr: string;
 };
 export declare function formatPermissionErrorDetail(value: string): string;
+/** Formats only caught permission-query failures without invoking user code. */
+export declare function formatCaughtPermissionFailure(error: unknown): string;
 export declare class PermissionCommandError extends Error implements PermissionCommandFailure {
     readonly command: string;
     readonly durationMs: number;

package/dist/permission-exec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permission-exec.d.ts","sourceRoot":"","sources":["../src/permission-exec.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE;AAgBD,qBAAa,sBAAuB,SAAQ,KAAM,YAAW,wBAAwB;IACnF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YACE,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,OAAO,EACd,SAAS,SAAqC,EAc/C;CACF;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,wBAAwB,GAAG,SAAS,CAgBtC;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAqC,GAC7C,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa7C"}
+{"version":3,"file":"permission-exec.d.ts","sourceRoot":"","sources":["../src/permission-exec.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE;AA4ED,gFAAgF;AAChF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAqBpE;AA2CD,qBAAa,sBAAuB,SAAQ,KAAM,YAAW,wBAAwB;IACnF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YACE,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,OAAO,EACd,SAAS,SAAqC,EAc/C;CACF;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,wBAAwB,GAAG,SAAS,CAgCtC;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,SAAqC,GAC7C,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa7C"}

package/dist/permission-exec.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import path from "node:path";
-import { promisify } from "node:util";
+import { promisify, types as utilTypes } from "node:util";
 import { formatErrorDetail } from "./error-detail.js";
 const execFileAsync = promisify(execFile);
 export const DEFAULT_PERMISSION_EXEC_TIMEOUT_MS = 30_000;
@@ -8,15 +8,127 @@ export function formatPermissionErrorDetail(value) {
     const formatted = formatErrorDetail(value);
     return formatted.length > 400 ? `${formatted.slice(0, 399)}…` : formatted;
 }
+const MISSING_DATA_PROPERTY = Object.freeze({ found: false });
+const MAX_CAUGHT_FAILURE_PROTOTYPES = 4;
+const primitiveString = String;
+const isUint8Array = utilTypes.isUint8Array;
+const Uint8ArrayIntrinsic = Uint8Array;
+const typedArrayPrototype = Object.getPrototypeOf(Uint8ArrayIntrinsic.prototype);
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+const typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+const typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
+const typedArraySet = Object.getOwnPropertyDescriptor(typedArrayPrototype, "set").value;
+const textDecoderDecode = TextDecoder.prototype.decode;
+const stderrDecoder = new TextDecoder("utf-8", {
+    fatal: false,
+    ignoreBOM: true,
+});
+const MAX_STDERR_BYTES = 1600;
+function isInspectableCaughtObject(value) {
+    if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+        return false;
+    }
+    try {
+        return !utilTypes.isProxy(value);
+    }
+    catch {
+        return false;
+    }
+}
+function dataProperty(value, name) {
+    if (!isInspectableCaughtObject(value))
+        return MISSING_DATA_PROPERTY;
+    let current = value;
+    for (let depth = 0; current !== null && depth < MAX_CAUGHT_FAILURE_PROTOTYPES; depth += 1) {
+        if (!isInspectableCaughtObject(current))
+            return MISSING_DATA_PROPERTY;
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(current, name);
+        }
+        catch {
+            return MISSING_DATA_PROPERTY;
+        }
+        if (descriptor) {
+            return Object.hasOwn(descriptor, "value")
+                ? { found: true, value: descriptor.value }
+                : MISSING_DATA_PROPERTY;
+        }
+        try {
+            current = Object.getPrototypeOf(current);
+        }
+        catch {
+            return MISSING_DATA_PROPERTY;
+        }
+    }
+    return MISSING_DATA_PROPERTY;
+}
+function caughtPrimitiveDisplay(value) {
+    if (value !== null && (typeof value === "object" || typeof value === "function"))
+        return undefined;
+    return primitiveString(value);
+}
+/** Formats only caught permission-query failures without invoking user code. */
+export function formatCaughtPermissionFailure(error) {
+    const primitive = caughtPrimitiveDisplay(error);
+    if (primitive !== undefined)
+        return formatBoundedCaughtDetail(primitive);
+    if (!isInspectableCaughtObject(error)) {
+        return "Uninspectable proxy failure";
+    }
+    const message = dataProperty(error, "message");
+    const name = dataProperty(error, "name");
+    const rawMessage = message.found && typeof message.value === "string"
+        ? message.value : "";
+    const rawName = name.found && typeof name.value === "string"
+        ? name.value : "";
+    const messageText = rawMessage.slice(0, 400);
+    const nameText = rawName.slice(0, 400);
+    const display = messageText
+        ? (nameText ? `${nameText}: ${messageText}` : messageText)
+        : nameText || (typeof error === "function" ? "Unknown function failure" : "Unknown object failure");
+    return formatBoundedCaughtDetail(display, rawMessage.length > messageText.length || rawName.length > nameText.length);
+}
+function formatBoundedCaughtDetail(value, alreadyTruncated = false) {
+    const inputWasTruncated = alreadyTruncated || value.length > 400;
+    const formatted = formatPermissionErrorDetail(value.slice(0, 400));
+    if (!inputWasTruncated || formatted.endsWith("…"))
+        return formatted;
+    return `${formatted.slice(0, 399)}…`;
+}
+function safeStderr(value) {
+    if (typeof value === "string")
+        return formatBoundedCaughtDetail(value);
+    try {
+        if (!isUint8Array(value))
+            return "";
+        const backing = Reflect.apply(typedArrayBufferGetter, value, []);
+        const byteOffset = Reflect.apply(typedArrayByteOffsetGetter, value, []);
+        const byteLength = Reflect.apply(typedArrayByteLengthGetter, value, []);
+        const copiedByteLength = byteLength < MAX_STDERR_BYTES
+            ? byteLength : MAX_STDERR_BYTES;
+        const source = new Uint8ArrayIntrinsic(backing, byteOffset, copiedByteLength);
+        const copy = new Uint8ArrayIntrinsic(copiedByteLength);
+        Reflect.apply(typedArraySet, copy, [source, 0]);
+        const decoded = Reflect.apply(textDecoderDecode, stderrDecoder, [copy]);
+        return formatBoundedCaughtDetail(decoded, byteLength > copiedByteLength);
+    }
+    catch {
+        return "";
+    }
+}
 function commandFailureFields(error) {
-    const fields = error && typeof error === "object" ? error : {};
+    const killed = dataProperty(error, "killed");
+    const code = dataProperty(error, "code");
+    const signal = dataProperty(error, "signal");
+    const stderr = dataProperty(error, "stderr");
     return {
-        timedOut: "killed" in fields && fields.killed === true &&
-            "signal" in fields && fields.signal === "SIGKILL",
-        exitCode: "code" in fields && typeof fields.code === "number" ? fields.code : null,
-        signal: "signal" in fields && typeof fields.signal === "string" ? fields.signal : null,
-        stderr: formatPermissionErrorDetail("stderr" in fields && (typeof fields.stderr === "string" || Buffer.isBuffer(fields.stderr))
-            ? fields.stderr.toString() : ""),
+        found: killed.found || code.found || signal.found || stderr.found,
+        timedOut: killed.found && killed.value === true &&
+            signal.found && signal.value === "SIGKILL",
+        exitCode: code.found && typeof code.value === "number" ? code.value : null,
+        signal: signal.found && typeof signal.value === "string" ? signal.value : null,
+        stderr: stderr.found ? safeStderr(stderr.value) : "",
     };
 }
 export class PermissionCommandError extends Error {
@@ -41,21 +153,38 @@ export class PermissionCommandError extends Error {
     }
 }
 export function getPermissionCommandFailure(error, command, durationMs) {
-    if (error instanceof PermissionCommandError) {
-        return {
-            command: error.command,
-            durationMs: error.durationMs,
-            timedOut: error.timedOut,
-            exitCode: error.exitCode,
-            signal: error.signal,
-            stderr: error.stderr,
-        };
+    if (isInspectableCaughtObject(error) && utilTypes.isNativeError(error)) {
+        const name = dataProperty(error, "name");
+        if (name.found && name.value === "PermissionCommandError") {
+            const wrappedCommand = dataProperty(error, "command");
+            const wrappedDuration = dataProperty(error, "durationMs");
+            const wrappedTimedOut = dataProperty(error, "timedOut");
+            const wrappedExitCode = dataProperty(error, "exitCode");
+            const wrappedSignal = dataProperty(error, "signal");
+            const wrappedStderr = dataProperty(error, "stderr");
+            if (wrappedCommand.found && typeof wrappedCommand.value === "string" &&
+                wrappedDuration.found && typeof wrappedDuration.value === "number" &&
+                Number.isSafeInteger(wrappedDuration.value) && wrappedDuration.value >= 0 &&
+                wrappedTimedOut.found && typeof wrappedTimedOut.value === "boolean" &&
+                wrappedExitCode.found && (wrappedExitCode.value === null || typeof wrappedExitCode.value === "number") &&
+                wrappedSignal.found && (wrappedSignal.value === null || typeof wrappedSignal.value === "string") &&
+                wrappedStderr.found) {
+                return {
+                    command: wrappedCommand.value,
+                    durationMs: wrappedDuration.value,
+                    timedOut: wrappedTimedOut.value,
+                    exitCode: wrappedExitCode.value,
+                    signal: wrappedSignal.value,
+                    stderr: safeStderr(wrappedStderr.value),
+                };
+            }
+        }
     }
-    if (!error || typeof error !== "object" ||
-        !("code" in error || "signal" in error || "killed" in error || "stderr" in error)) {
+    const fields = commandFailureFields(error);
+    if (!fields.found)
         return undefined;
-    }
-    return { command, durationMs: Math.round(durationMs), ...commandFailureFields(error) };
+    const { found: _found, ...detail } = fields;
+    return { command, durationMs: Math.round(durationMs), ...detail };
 }
 export async function executePermissionCommand(command, args, timeoutMs = DEFAULT_PERMISSION_EXEC_TIMEOUT_MS) {
     const startedAt = performance.now();

package/dist/permissions-windows.js

@@ -96,7 +96,7 @@ export async function inspectWindowsPermissions(params) {
         env: params.opts?.env,
         exec: params.opts?.exec ?? defaultPermissionExec,
     });
-    if (owner.error) {
+    if (owner.error !== undefined) {
         const error = `Windows owner inspection failed: ${owner.error}`;
         return { ...unverified, ownerError: owner.error, error, errorDetail: owner.errorDetail, errorCause: owner.errorCause };
     }

package/dist/pinned-mutation-admission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pinned-mutation-admission.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-admission.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAGvF,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,KAAK,EAKV,4BAA4B,EAC7B,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAgCtE,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C,CAAC,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,gBAAgB,EAAE,qBAAqB,GAAG,SAAS,GAClD,4BAA4B,GAAG,SAAS,CAO1C;AAuJD,wBAAsB,mCAAmC,CAAC,MAAM,EAAE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yBAAyB,EAAE,MAAM,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,4BAA4B,GAAG,SAAS,CAAC;IACjD,cAAc,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD,GAAG,OAAO,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC,CA2PD"}
+{"version":3,"file":"pinned-mutation-admission.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-admission.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAGvF,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,KAAK,EAKV,4BAA4B,EAC7B,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAgCtE,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C,CAAC,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,gBAAgB,EAAE,qBAAqB,GAAG,SAAS,GAClD,4BAA4B,GAAG,SAAS,CAO1C;AAuJD,wBAAsB,mCAAmC,CAAC,MAAM,EAAE;IAChE,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yBAAyB,EAAE,MAAM,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,4BAA4B,GAAG,SAAS,CAAC;IACjD,cAAc,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD,GAAG,OAAO,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;CAClD,CAAC,CAgQD"}

package/dist/pinned-mutation-admission.js

@@ -165,6 +165,10 @@ export async function preparePinnedWriteMutationAdmission(params) {
         selectedTarget: params.resolvedTargetPath,
         policy,
     });
+    const nativeRoute = sharedRoute ?? (process.platform === "win32" && params.originalPath?.includes("/")
+        ? simpleSharedRoute({ rootReal: params.rootReal, rootIdentity: params.rootIdentity,
+            originalPath: params.originalPath.replaceAll("/", "\\"), selectedTarget: params.resolvedTargetPath, policy })
+        : undefined);
     let pinnedSession;
     let epoch;
     let pending;
@@ -194,13 +198,13 @@ export async function preparePinnedWriteMutationAdmission(params) {
         }
         return current;
     };
-    const beginSharedParentWalk = sharedRoute ? () => {
+    const createSharedParentWalk = (admittedRoute) => {
         const session = Object.freeze({
             kind: "shared",
-            route: sharedRoute.route,
+            route: admittedRoute.route,
             selectedTarget: params.resolvedTargetPath,
             nativeMode: getFsSafeNativeConfig().mode,
-            rootIdentity: sharedRoute.rootIdentity,
+            rootIdentity: admittedRoute.rootIdentity,
             authorizationToken: Object.freeze({}),
         });
         let disposed = false;
@@ -314,7 +318,7 @@ export async function preparePinnedWriteMutationAdmission(params) {
                 disable();
             },
         });
-    } : undefined;
+    };
     const mutationAdmission = Object.freeze({
         rejectParentSymlinks: policy.mutationSymlinks === "reject",
         beginParentWalk: route ? () => {
@@ -329,7 +333,8 @@ export async function preparePinnedWriteMutationAdmission(params) {
             pending = undefined;
             return route;
         } : undefined,
-        beginSharedParentWalk,
+        beginSharedParentWalk: sharedRoute ? () => createSharedParentWalk(sharedRoute) : undefined,
+        beginNativeParentWalk: nativeRoute ? () => createSharedParentWalk(nativeRoute) : undefined,
         tryAuthorizeAtParent(request, parent) {
             pending = undefined;
             const reusable = epoch;

package/dist/pinned-mutation-observation.d.ts

@@ -30,7 +30,6 @@ export type MutationPathObservation = Readonly<{
 export declare function missingMutationSegments(observation: MutationPathObservation): number;
 export declare function nextMissingMutationPath(observation: MutationPathObservation): string | undefined;
 export declare function checkedMutationDirectory(pathname: string, canonicalPath: string, stat: Pick<BigIntStats, "dev" | "ino" | "mode" | "nlink">, observeCurrent?: MutationDirectoryObserver): MutationDirectoryObservation;
-export declare function mutationDirectoryObservationCurrent(observation: MutationDirectoryObservation): boolean;
 export declare function mutationObservationUsesDirectory(observation: MutationPathObservation, directory: MutationDirectoryObservation): boolean;
 export declare function observeMutationPath(pathname: string): MutationPathObservation | undefined;
 export declare function mutationObservationCurrent(observation: MutationPathObservation): boolean;

package/dist/pinned-mutation-observation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pinned-mutation-observation.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-observation.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM/C,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,QAAA,MAAM,2BAA2B,eAAmD,CAAC;AAGrF,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAEnF,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,2BAA2B,CAAC,EAAE,IAAI,CAAC;CACrC,CAAC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,CAAC;AA6BH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,uBAAuB,GAAG,MAAM,CAEpF;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAGhG;AAKD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC,EACzD,cAAc,CAAC,EAAE,yBAAyB,GACzC,4BAA4B,CAY9B;AAQD,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,4BAA4B,GACxC,OAAO,CAgBT;AAED,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,4BAA4B,GACtC,OAAO,CAMT;AAGD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CA0BzF;AAED,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,uBAAuB,GAAG,OAAO,CAaxF;AAKD,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,SAAS,uBAAuB,EAAE,EAChD,WAAW,EAAE,SAAS,4BAA4B,EAAE,GACnD,OAAO,CAiET;AAID,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,uBAAuB,EACpC,MAAM,EAAE,4BAA4B,EACpC,KAAK,EAAE,4BAA4B,GAClC,uBAAuB,GAAG,SAAS,CAiBrC"}
+{"version":3,"file":"pinned-mutation-observation.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-observation.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM/C,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,QAAA,MAAM,2BAA2B,eAAmD,CAAC;AAGrF,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,wBAAwB,GAAG,SAAS,CAAC;AAEnF,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,2BAA2B,CAAC,EAAE,IAAI,CAAC;CACrC,CAAC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,CAAC;AA6BH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,uBAAuB,GAAG,MAAM,CAEpF;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,uBAAuB,GAAG,MAAM,GAAG,SAAS,CAGhG;AAKD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC,EACzD,cAAc,CAAC,EAAE,yBAAyB,GACzC,4BAA4B,CAY9B;AAQD,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,4BAA4B,GACtC,OAAO,CAMT;AAGD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS,CA0BzF;AAED,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,uBAAuB,GAAG,OAAO,CAaxF;AAKD,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,SAAS,uBAAuB,EAAE,EAChD,WAAW,EAAE,SAAS,4BAA4B,EAAE,GACnD,OAAO,CAiET;AAID,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,uBAAuB,EACpC,MAAM,EAAE,4BAA4B,EACpC,KAAK,EAAE,4BAA4B,GAClC,uBAAuB,GAAG,SAAS,CAiBrC"}

package/dist/pinned-mutation-observation.js

@@ -54,25 +54,6 @@ function checkedDirectory(observation) {
         path.isAbsolute(observation.path) && path.isAbsolute(observation.canonicalPath) &&
         directoryMode(observation.identity.mode);
 }
-export function mutationDirectoryObservationCurrent(observation) {
-    if (!checkedDirectory(observation))
-        return false;
-    try {
-        const observed = directoryObservers.get(observation)?.();
-        if (observed) {
-            return directoryMode(observed.identity.mode) &&
-                sameIdentity(observation.identity, observed.identity) &&
-                observed.canonicalPath === observation.canonicalPath;
-        }
-        const stat = inspectFileIdentitySync(() => fs.lstatSync(observation.path, { bigint: true }));
-        return stat.isDirectory() && !stat.isSymbolicLink() &&
-            sameIdentity(observation.identity, stat) &&
-            realpathSync.native(observation.path) === observation.canonicalPath;
-    }
-    catch {
-        return false;
-    }
-}
 export function mutationObservationUsesDirectory(observation, directory) {
     return checkedDirectory(directory) &&
         observation.ancestor === directory.path &&

package/dist/pinned-mutation-shared-route.d.ts

@@ -9,6 +9,7 @@ type SharedMutationPolicy = Readonly<{
     denyMutations?: DenyMutationPolicy;
     mutationSymlinks?: MutationSymlinkPolicy;
 }>;
+export declare function ordinaryWindowsSegments(relativePath: string): boolean;
 export declare function ordinarySharedAbsoluteInsideRoot(rootReal: string, candidatePath: string, rootIdentity: ExactRootIdentity): boolean;
 export declare function simpleSharedRoute(params: {
     rootReal: string;

package/dist/pinned-mutation-shared-route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pinned-mutation-shared-route.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-shared-route.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEtE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEvE,KAAK,oBAAoB,GAAG,QAAQ,CAAC;IACnC,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C,CAAC,CAAC;AA+BH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,iBAAiB,GAC9B,OAAO,CAeT;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,oBAAoB,CAAC;CAC9B,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,iBAAiB,CAAA;CAAE,GAAG,SAAS,CAqBjE"}
+{"version":3,"file":"pinned-mutation-shared-route.d.ts","sourceRoot":"","sources":["../src/pinned-mutation-shared-route.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEtE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEvE,KAAK,oBAAoB,GAAG,QAAQ,CAAC;IACnC,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C,CAAC,CAAC;AAQH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAMrE;AAiBD,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,iBAAiB,GAC9B,OAAO,CAeT;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,oBAAoB,CAAC;CAC9B,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,iBAAiB,CAAA;CAAE,GAAG,SAAS,CAqBjE"}

package/dist/pinned-mutation-shared-route.js

@@ -7,7 +7,7 @@ function windowsReservedDeviceSegment(segment) {
     const stem = segment.slice(0, extension < 0 ? segment.length : extension).toUpperCase();
     return WINDOWS_RESERVED_DEVICE_NAMES.has(stem);
 }
-function ordinaryWindowsSegments(relativePath) {
+export function ordinaryWindowsSegments(relativePath) {
     if (relativePath === "" || relativePath.includes("/") || relativePath.includes("\0"))
         return false;
     const segments = relativePath.split("\\");

package/dist/pinned-write-input.d.ts

@@ -0,0 +1,4 @@
+import type { FileHandle } from "node:fs/promises";
+import type { PinnedWriteInput } from "./pinned-write-types.js";
+export declare function writePinnedInput(target: FileHandle | number, input: PinnedWriteInput, maxBytes?: number, assertBeforeMutation?: () => void): Promise<void>;
+//# sourceMappingURL=pinned-write-input.d.ts.map

package/dist/pinned-write-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-write-input.d.ts","sourceRoot":"","sources":["../src/pinned-write-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,UAAU,GAAG,MAAM,EAC3B,KAAK,EAAE,gBAAgB,EACvB,QAAQ,CAAC,EAAE,MAAM,EACjB,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/dist/pinned-write-input.js

@@ -0,0 +1,25 @@
+import { writeCopyFileToFd } from "./copy-file-input.js";
+import { FsSafeError } from "./errors.js";
+import { writeAllToFile } from "./write-file-handle.js";
+export async function writePinnedInput(target, input, maxBytes, assertBeforeMutation) {
+    if (input.kind === "file") {
+        await writeCopyFileToFd(typeof target === "number" ? target : target.fd, input, maxBytes, assertBeforeMutation);
+        return;
+    }
+    let bytes = 0;
+    const write = async (data) => {
+        bytes += data.byteLength;
+        if (maxBytes !== undefined && bytes > maxBytes) {
+            throw new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
+        }
+        await writeAllToFile(target, data, { assertBeforeMutation });
+    };
+    if (input.kind === "buffer") {
+        await write(typeof input.data === "string" ? Buffer.from(input.data, input.encoding ?? "utf8") : input.data);
+    }
+    else {
+        for await (const chunk of input.stream) {
+            await write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+    }
+}

package/dist/pinned-write-mode.d.ts

@@ -0,0 +1,5 @@
+import type { FileHandle } from "node:fs/promises";
+export declare function assertPinnedWriteMode(fd: number, mode: number): void;
+export declare function preparePinnedWriteMode(handle: FileHandle, createdMode: number, assertBeforeMutation?: () => void): Promise<(() => void) | undefined>;
+export declare function pinnedWriteModeAssertion(fd: number, mode: number, assertBeforeMutation?: () => void): () => void;
+//# sourceMappingURL=pinned-write-mode.d.ts.map

package/dist/pinned-write-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-write-mode.d.ts","sourceRoot":"","sources":["../src/pinned-write-mode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAKpE;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,MAAM,EACnB,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,OAAO,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAKnC;AAED,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,MAAM,IAAI,CAKZ"}