@veryfront/ext-content-mdx 0.1.1185 → 0.1.1188

package/esm/src/platform/compat/fs.js

@@ -1,6 +1,45 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 import { isBun, isDeno, isNode } from "./runtime.js";
+import { validateTempDirectoryPrefix } from "./temp-directory-prefix.js";
+import { readFileWithinLimit } from "../adapters/bounded-file-read.js";
+import { captureExclusiveCreateCapability, captureSnapshotReadCapability, } from "../adapters/file-system-capabilities.js";
+import { isProxyWithoutHooks } from "./error-introspection.js";
+import { isNotFoundError } from "./not-found-error.js";
+export { isNotFoundError };
+const DEFAULT_TEMP_DIRECTORY_PREFIX = "tmp-";
+const UNSUPPORTED_CHMOD_ERROR_CODES = new Set([
+    "ENOSYS",
+    "ENOTSUP",
+    "EOPNOTSUPP",
+]);
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const reflectApply = Reflect.apply;
+function hasOwnDataValue(value, key, expected) {
+    const descriptor = getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined &&
+        reflectApply(hasOwnProperty, descriptor, ["value"]) === true &&
+        descriptor.value === expected;
+}
+function isUnsupportedChmodError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "NotSupported")
+        return true;
+    const code = error.code;
+    return typeof code === "string" && UNSUPPORTED_CHMOD_ERROR_CODES.has(code);
+}
+function normalizePathIdentity(device, inode) {
+    const isValidPart = (value) => (typeof value === "bigint" && value >= 0n) ||
+        (typeof value === "number" && Number.isSafeInteger(value) && value >= 0);
+    if (!isValidPart(device) || !isValidPart(inode))
+        return undefined;
+    return Object.freeze({
+        device: String(device),
+        inode: String(inode),
+    });
+}
 /**
  * Typed accessor for the Deno global.
  *
@@ -60,6 +99,16 @@ class NodeFileSystem {
         await this.ensureInitialized();
         return this.getFs().readFile(path);
     }
+    async readFileBytesWithinLimit(path, byteLimit) {
+        await this.ensureInitialized();
+        return await readFileWithinLimit(async () => {
+            const handle = await this.getFs().open(path, "r");
+            return {
+                close: () => handle.close(),
+                read: async (buffer) => (await handle.read(buffer)).bytesRead,
+            };
+        }, byteLimit);
+    }
     async writeTextFile(path, data) {
         await this.ensureInitialized();
         await this.getFs().writeFile(path, data, { encoding: "utf8" });
@@ -68,6 +117,10 @@ class NodeFileSystem {
         await this.ensureInitialized();
         await this.getFs().writeFile(path, data);
     }
+    async rename(from, to) {
+        await this.ensureInitialized();
+        await this.getFs().rename(from, to);
+    }
     async exists(path) {
         await this.ensureInitialized();
         try {
@@ -75,7 +128,7 @@ class NodeFileSystem {
             return true;
         }
         catch (error) {
-            if (error?.code === "ENOENT")
+            if (isNotFoundError(error))
                 return false;
             throw error;
         }
@@ -121,23 +174,26 @@ class NodeFileSystem {
     async remove(path, options) {
         await this.ensureInitialized();
         const recursive = options?.recursive ?? false;
-        await this.getFs().rm(path, { recursive, force: recursive });
+        await this.getFs().rm(path, { recursive, force: false });
     }
     async makeTempDir(options) {
         await this.ensureInitialized();
-        const tempDir = this.getPath().join(this.getOs().tmpdir(), `${options?.prefix ?? "tmp-"}${dntShim.crypto.randomUUID().slice(0, 8)}`);
-        await this.getFs().mkdir(tempDir, { recursive: true });
-        return tempDir;
+        const prefix = validateTempDirectoryPrefix(options?.prefix ?? DEFAULT_TEMP_DIRECTORY_PREFIX);
+        const tempRoot = this.getOs().tmpdir();
+        const separator = this.getPath().sep;
+        const tempRootPrefix = tempRoot.endsWith(separator) ? tempRoot : `${tempRoot}${separator}`;
+        return await this.getFs().mkdtemp(`${tempRootPrefix}${prefix}`);
     }
     async chmod(path, mode) {
         await this.ensureInitialized();
         try {
             await this.getFs().chmod(path, mode);
         }
-        catch {
-            // Ignore errors on Windows where chmod is not fully supported.
-            // Intentionally not logged: this low-level compat module must stay
-            // importable without `--allow-env` (the logger reads env at import).
+        catch (error) {
+            if (this.getOs().platform() === "win32" && isUnsupportedChmodError(error)) {
+                return;
+            }
+            throw error;
         }
     }
 }
@@ -148,19 +204,31 @@ class DenoFileSystem {
     readFile(path) {
         return denoGlobal().readFile(path);
     }
+    async readFileBytesWithinLimit(path, byteLimit) {
+        return await readFileWithinLimit(async () => {
+            const file = await denoGlobal().open(path, { read: true });
+            return {
+                close: () => file.close(),
+                read: (buffer) => file.read(buffer),
+            };
+        }, byteLimit);
+    }
     async writeTextFile(path, data) {
         await denoGlobal().writeTextFile(path, data);
     }
     async writeFile(path, data) {
         await denoGlobal().writeFile(path, data);
     }
+    async rename(from, to) {
+        await denoGlobal().rename(from, to);
+    }
     async exists(path) {
         try {
             await denoGlobal().stat(path);
             return true;
         }
         catch (error) {
-            if (error instanceof denoGlobal().errors.NotFound)
+            if (isNotFoundError(error))
                 return false;
             throw error;
         }
@@ -201,21 +269,52 @@ class DenoFileSystem {
     async remove(path, options) {
         await denoGlobal().remove(path, { recursive: options?.recursive ?? false });
     }
-    makeTempDir(options) {
-        return denoGlobal().makeTempDir({ prefix: options?.prefix });
+    async makeTempDir(options) {
+        const prefix = validateTempDirectoryPrefix(options?.prefix ?? DEFAULT_TEMP_DIRECTORY_PREFIX);
+        return await denoGlobal().makeTempDir({ prefix });
     }
     async chmod(path, mode) {
         try {
             await denoGlobal().chmod(path, mode);
         }
-        catch (_) {
-            /* expected: chmod is not fully supported on Windows */
+        catch (error) {
+            if (denoGlobal().build.os === "windows" && isUnsupportedChmodError(error)) {
+                return;
+            }
+            throw error;
         }
     }
 }
-/** Create file system. */
+/** Create the runtime-native filesystem implementation. */
 export function createFileSystem() {
-    return isDeno ? new DenoFileSystem() : new NodeFileSystem();
+    const fileSystem = isDeno ? new DenoFileSystem() : new NodeFileSystem();
+    let semanticAdapter;
+    const loadSemanticAdapter = () => semanticAdapter ??= isDeno
+        ? import("../adapters/runtime/deno/filesystem-adapter.js")
+            .then(({ DenoFileSystemAdapter }) => new DenoFileSystemAdapter())
+        : import("../adapters/runtime/shared/node-filesystem-adapter.js")
+            .then(({ NodeCompatibleFileSystemAdapter }) => new NodeCompatibleFileSystemAdapter());
+    Object.defineProperty(fileSystem, "readFileSnapshotWithinLimit", {
+        value: async (path, containmentRoot, byteLimit) => {
+            const snapshotReader = captureSnapshotReadCapability(await loadSemanticAdapter(), "Native filesystem adapter");
+            if (snapshotReader === undefined) {
+                throw new Error("Native filesystem adapter does not support snapshot reads");
+            }
+            return await snapshotReader.read(path, containmentRoot, byteLimit);
+        },
+        enumerable: true,
+    });
+    Object.defineProperty(fileSystem, "createFileBytesExclusive", {
+        value: async (path, content) => {
+            const exclusiveCreator = captureExclusiveCreateCapability(await loadSemanticAdapter(), "Native filesystem adapter");
+            if (exclusiveCreator === undefined) {
+                throw new Error("Native filesystem adapter does not support exclusive creates");
+            }
+            await exclusiveCreator.create(path, content);
+        },
+        enumerable: true,
+    });
+    return fileSystem;
 }
 let _fs = null;
 function getFs() {
@@ -238,7 +337,7 @@ export function writeTextFile(path, data) {
 export function writeFile(path, data) {
     return getFs().writeFile(path, data);
 }
-/** Check whether a path exists. */
+/** Return false for a missing path and propagate every other filesystem error. */
 export function exists(path) {
     return getFs().exists(path);
 }
@@ -268,11 +367,25 @@ export async function lstat(path) {
         mtime: info.mtime,
     };
 }
+/**
+ * Read a path's native device/inode identity without following a terminal
+ * symbolic link. Returns undefined only when the runtime cannot expose a
+ * stable identity for the backing filesystem.
+ */
+export async function getPathIdentity(path) {
+    if (isDeno) {
+        const info = await denoGlobal().lstat(path);
+        return normalizePathIdentity(info.dev, info.ino);
+    }
+    const fs = await import("node:fs/promises");
+    const info = await fs.lstat(path, { bigint: true });
+    return normalizePathIdentity(info.dev, info.ino);
+}
 /** Create a directory. */
 export function mkdir(path, options) {
     return getFs().mkdir(path, options);
 }
-/** Remove a file or directory. */
+/** Remove a file or directory, rejecting when the path does not exist. */
 export function remove(path, options) {
     return getFs().remove(path, options);
 }
@@ -280,11 +393,11 @@ export function remove(path, options) {
 export function readDir(path) {
     return getFs().readDir(path);
 }
-/** Create temp dir. */
+/** Atomically create a unique directory beneath the operating-system temp root. */
 export function makeTempDir(options) {
     return getFs().makeTempDir(options);
 }
-/** Change file permissions. */
+/** Change file permissions, rejecting operational failures. */
 export function chmod(path, mode) {
     return getFs().chmod(path, mode);
 }
@@ -308,29 +421,18 @@ export async function realPath(path) {
     const fs = await import("node:fs/promises");
     return await fs.realpath(path);
 }
-/** Error shape for is not found. */
-export function isNotFoundError(error, seen = new Set()) {
-    if (seen.has(error))
+/** Error shape for is already exists. */
+export function isAlreadyExistsError(error) {
+    if (typeof error !== "object" || error === null || isProxyWithoutHooks(error)) {
         return false;
-    seen.add(error);
-    const NotFound = dntShim.dntGlobalThis.Deno?.errors?.NotFound;
-    if (isDeno && NotFound && error instanceof NotFound)
-        return true;
-    if (error?.code === "ENOENT")
-        return true;
-    if (error instanceof Error && error.name === "VeryfrontError" &&
-        error.slug === "file-not-found") {
-        return true;
     }
-    if (error instanceof Error && "cause" in error) {
-        return isNotFoundError(error.cause, seen);
+    try {
+        const AlreadyExists = isDeno ? denoGlobal().errors.AlreadyExists : undefined;
+        if (AlreadyExists && error instanceof AlreadyExists)
+            return true;
+        return hasOwnDataValue(error, "code", "EEXIST");
+    }
+    catch {
+        return false;
     }
-    return false;
-}
-/** Error shape for is already exists. */
-export function isAlreadyExistsError(error) {
-    const AlreadyExists = dntShim.dntGlobalThis.Deno?.errors?.AlreadyExists;
-    if (isDeno && AlreadyExists && error instanceof AlreadyExists)
-        return true;
-    return error?.code === "EEXIST";
 }

package/esm/src/platform/compat/native-brand-checks.d.ts

@@ -0,0 +1,14 @@
+export interface NativeBrandChecks {
+    isAsyncFunction(value: unknown): boolean;
+    isNativeError(value: unknown): boolean;
+    isPromise(value: unknown): boolean;
+    isProxy(value: unknown): boolean;
+    isUint8Array(value: unknown): boolean;
+}
+/**
+ * Immutable host brand checks captured once at the runtime trust boundary.
+ * Browser and edge hosts without Node-compatible primitives remain linkable
+ * and use the conservative callers in error-introspection.ts.
+ */
+export declare const nativeBrandChecks: NativeBrandChecks | undefined;
+//# sourceMappingURL=native-brand-checks.d.ts.map

package/esm/src/platform/compat/native-brand-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-brand-checks.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/native-brand-checks.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACzC,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACvC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACnC,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACjC,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CACvC;AA+ED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,+BAE7B,CAAC"}

package/esm/src/platform/compat/native-brand-checks.js

@@ -0,0 +1,68 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { isBun, isDeno, isNode } from "./runtime.js";
+const apply = Reflect.apply;
+const createObject = Object.create;
+const defineProperty = Object.defineProperty;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const objectHasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(object, key) {
+    return apply(objectHasOwnProperty, object, [key]);
+}
+function readOwnDataFunction(source, key) {
+    const descriptor = getOwnPropertyDescriptor(source, key);
+    if (!descriptor || !hasOwn(descriptor, "value"))
+        return undefined;
+    return typeof descriptor.value === "function" ? descriptor.value : undefined;
+}
+function snapshotNativeBrandChecks(value) {
+    if ((typeof value !== "object" && typeof value !== "function") || value === null) {
+        return undefined;
+    }
+    const snapshot = createObject(null);
+    for (const key of [
+        "isAsyncFunction",
+        "isNativeError",
+        "isPromise",
+        "isProxy",
+        "isUint8Array",
+    ]) {
+        const check = readOwnDataFunction(value, key);
+        if (!check)
+            return undefined;
+        defineProperty(snapshot, key, {
+            configurable: false,
+            enumerable: true,
+            value: check,
+            writable: false,
+        });
+    }
+    return freeze(snapshot);
+}
+function loadNativeBrandCheckModule() {
+    if (!isBun && !isDeno && !isNode)
+        return undefined;
+    const hostProcess = dntShim.dntGlobalThis.process;
+    if (hostProcess) {
+        const getBuiltinModule = readOwnDataFunction(hostProcess, "getBuiltinModule");
+        if (getBuiltinModule) {
+            return apply(getBuiltinModule, hostProcess, ["node:util/types"]);
+        }
+    }
+    // Bun exposes synchronous require() in ESM. This retains compatibility with
+    // Bun releases that predate process.getBuiltinModule without adding a Node
+    // builtin to browser module graphs.
+    if (isBun && typeof require === "function") {
+        return apply(require, undefined, ["node:util/types"]);
+    }
+    return undefined;
+}
+/**
+ * Immutable host brand checks captured once at the runtime trust boundary.
+ * Browser and edge hosts without Node-compatible primitives remain linkable
+ * and use the conservative callers in error-introspection.ts.
+ */
+export const nativeBrandChecks = snapshotNativeBrandChecks(loadNativeBrandCheckModule());
+if ((isBun || isDeno || isNode) && !nativeBrandChecks) {
+    throw new Error("The current server runtime does not expose complete node:util/types brand checks");
+}

package/esm/src/platform/compat/not-found-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strict absence classifier for fail-closed filesystem boundaries.
+ *
+ * Every value in the inspected cause chain must carry the runtime's native
+ * Error brand. This keeps arbitrary error-shaped records such as
+ * `{ code: "ENOENT" }` from being converted into ordinary absence while still
+ * recognizing native Deno, Node, and Veryfront not-found errors without
+ * invoking project-owned hooks.
+ */
+export declare function isCanonicalNotFoundError(error: unknown): boolean;
+export declare function isNotFoundError(error: unknown, seen?: Set<unknown>): boolean;
+//# sourceMappingURL=not-found-error.d.ts.map

package/esm/src/platform/compat/not-found-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found-error.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/not-found-error.ts"],"names":[],"mappings":"AAqMA;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,CAAC,OAAO,CAAa,GAAG,OAAO,CAEvF"}

package/esm/src/platform/compat/not-found-error.js

@@ -0,0 +1,174 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { isNativeErrorWithoutHooks, isProxyWithoutHooks, readNativeErrorNameWithoutHooks, } from "./error-introspection.js";
+import { isDeno } from "./runtime.js";
+const MAX_CAUSE_DEPTH = 64;
+const MAX_PROTOTYPE_DEPTH = 32;
+const NO_DATA_VALUE = Symbol("no-data-value");
+const NO_OWN_PROPERTY = Symbol("no-own-property");
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getPrototypeOf = Object.getPrototypeOf;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const reflectApply = Reflect.apply;
+const setAdd = Set.prototype.add;
+const setHas = Set.prototype.has;
+function hasOwn(value, key) {
+    return reflectApply(hasOwnProperty, value, [key]);
+}
+function readOwnDataValue(value, key) {
+    if (isProxyWithoutHooks(value))
+        return NO_DATA_VALUE;
+    try {
+        const descriptor = getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            return NO_OWN_PROPERTY;
+        return hasOwn(descriptor, "value") ? descriptor.value : NO_DATA_VALUE;
+    }
+    catch {
+        return NO_DATA_VALUE;
+    }
+}
+function readDataValue(value, key) {
+    let owner = value;
+    for (let depth = 0; owner !== null && depth < MAX_PROTOTYPE_DEPTH; depth++) {
+        const result = readOwnDataValue(owner, key);
+        if (result === NO_DATA_VALUE)
+            return NO_DATA_VALUE;
+        if (result !== NO_OWN_PROPERTY)
+            return result;
+        if (isProxyWithoutHooks(owner))
+            return NO_DATA_VALUE;
+        try {
+            owner = getPrototypeOf(owner);
+        }
+        catch {
+            return NO_DATA_VALUE;
+        }
+    }
+    return NO_DATA_VALUE;
+}
+function readClassifiedDataValue(value, key, ownOnly) {
+    if (!ownOnly)
+        return readDataValue(value, key);
+    const result = readOwnDataValue(value, key);
+    return result === NO_OWN_PROPERTY ? NO_DATA_VALUE : result;
+}
+function captureDenoNotFoundPrototype() {
+    if (!isDeno)
+        return undefined;
+    const deno = readOwnDataValue(dntShim.dntGlobalThis, "Deno");
+    if (typeof deno !== "object" || deno === null)
+        return undefined;
+    const errors = readOwnDataValue(deno, "errors");
+    if (typeof errors !== "object" || errors === null)
+        return undefined;
+    const NotFound = readOwnDataValue(errors, "NotFound");
+    if (typeof NotFound !== "function" || isProxyWithoutHooks(NotFound))
+        return undefined;
+    const prototype = readOwnDataValue(NotFound, "prototype");
+    return typeof prototype === "object" && prototype !== null ? prototype : undefined;
+}
+const denoNotFoundPrototype = captureDenoNotFoundPrototype();
+function inheritsFrom(value, expectedPrototype) {
+    let prototype = value;
+    for (let depth = 0; prototype !== null && depth < MAX_PROTOTYPE_DEPTH; depth++) {
+        if (isProxyWithoutHooks(prototype))
+            return false;
+        try {
+            prototype = getPrototypeOf(prototype);
+        }
+        catch {
+            return false;
+        }
+        if (prototype === expectedPrototype)
+            return true;
+    }
+    return false;
+}
+function normalizeSeenSet(seen) {
+    try {
+        reflectApply(setHas, seen, [seen]);
+        return seen;
+    }
+    catch {
+        return new Set();
+    }
+}
+function markSeen(seen, value) {
+    if (reflectApply(setHas, seen, [value]))
+        return false;
+    reflectApply(setAdd, seen, [value]);
+    return true;
+}
+function isLegacyFileNotFoundError(error, name, ownDataOnly) {
+    if (name !== "VeryfrontError[file]")
+        return false;
+    const context = readClassifiedDataValue(error, "context", ownDataOnly);
+    if (typeof context !== "object" || context === null ||
+        isProxyWithoutHooks(context)) {
+        return false;
+    }
+    const type = readClassifiedDataValue(context, "type", ownDataOnly);
+    const message = readClassifiedDataValue(context, "message", ownDataOnly);
+    return type === "file" &&
+        typeof message === "string" &&
+        /^(?:File|Path) not found:/.test(message);
+}
+/**
+ * Return whether an error or its bounded cause chain represents a path that
+ * cannot be resolved. ENOTDIR is included because a missing candidate beneath
+ * a file is just as absent as an ENOENT candidate during filesystem lookup.
+ * Project-owned accessors and Proxy traps are never evaluated.
+ */
+function classifyNotFoundError(error, seen, requireNativeCauseChain) {
+    const visited = normalizeSeenSet(seen);
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+        if (typeof current !== "object" || current === null ||
+            isProxyWithoutHooks(current) || !markSeen(visited, current)) {
+            return false;
+        }
+        if (requireNativeCauseChain && !isNativeErrorWithoutHooks(current)) {
+            return false;
+        }
+        const code = readClassifiedDataValue(current, "code", requireNativeCauseChain);
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return true;
+        if (!isNativeErrorWithoutHooks(current))
+            return false;
+        if (denoNotFoundPrototype && inheritsFrom(current, denoNotFoundPrototype)) {
+            return true;
+        }
+        const name = readNativeErrorNameWithoutHooks(current);
+        const structuralName = requireNativeCauseChain
+            ? readClassifiedDataValue(current, "name", true)
+            : name;
+        if (structuralName === "VeryfrontError" &&
+            readClassifiedDataValue(current, "slug", requireNativeCauseChain) === "file-not-found") {
+            return true;
+        }
+        if (typeof structuralName === "string" &&
+            isLegacyFileNotFoundError(current, structuralName, requireNativeCauseChain)) {
+            return true;
+        }
+        const cause = readClassifiedDataValue(current, "cause", requireNativeCauseChain);
+        if (cause === NO_DATA_VALUE)
+            return false;
+        current = cause;
+    }
+    return false;
+}
+/**
+ * Strict absence classifier for fail-closed filesystem boundaries.
+ *
+ * Every value in the inspected cause chain must carry the runtime's native
+ * Error brand. This keeps arbitrary error-shaped records such as
+ * `{ code: "ENOENT" }` from being converted into ordinary absence while still
+ * recognizing native Deno, Node, and Veryfront not-found errors without
+ * invoking project-owned hooks.
+ */
+export function isCanonicalNotFoundError(error) {
+    return classifyNotFoundError(error, new Set(), true);
+}
+export function isNotFoundError(error, seen = new Set()) {
+    return classifyNotFoundError(error, seen, false);
+}

package/esm/src/platform/compat/path/security.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/security.ts"],"names":[],"mappings":"AAMA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAsB1D"}
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/security.ts"],"names":[],"mappings":"AAEA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAmB1D"}

package/esm/src/platform/compat/path/security.js

@@ -1,13 +1,11 @@
-import { FORBIDDEN_PATH_PATTERNS, MAX_PATH_LENGTH, MAX_PATH_TRAVERSAL_DEPTH, } from "../../../utils/constants/security.js";
+import { MAX_PATH_LENGTH, MAX_PATH_TRAVERSAL_DEPTH } from "../../../utils/constants/security.js";
 export function validatePathSecurity(path) {
     if (path == null)
         return false;
     if (path.length > MAX_PATH_LENGTH)
         return false;
-    for (const pattern of FORBIDDEN_PATH_PATTERNS) {
-        if (pattern.test(path))
-            return false;
-    }
+    if (path.includes("\0"))
+        return false;
     const parts = path.split(/[\/\\]/);
     let depth = 0;
     for (const part of parts) {

package/esm/src/platform/compat/process/command.d.ts

@@ -3,6 +3,8 @@ export interface CommandResult {
     code: number;
     stdout?: string;
     stderr?: string;
+    /** True when captured output exceeded the configured byte limit. */
+    outputTruncated?: boolean;
 }
 export interface CommandOptions {
     args?: string[];
@@ -16,9 +18,30 @@ export interface CommandOptions {
     inherit?: boolean;
     /** Use shell to run the command (needed for .cmd files on Windows) */
     shell?: boolean;
-    /** Kill the command if it exceeds this duration (milliseconds) */
+    /**
+     * Kill the command after this duration in milliseconds. Positive values are
+     * floored to whole milliseconds and clamped to the portable timer maximum;
+     * `undefined`, non-positive values, and NaN disable the timeout.
+     */
     timeoutMs?: number;
+    /** Terminate the command when the caller cancels. */
+    signal?: AbortSignal;
+    /**
+     * Best-effort process-tree cleanup after the managed command settles.
+     * Disabled by default so generic callers retain normal daemon/background
+     * process behavior. Sandboxed or otherwise lifecycle-owning callers can
+     * enable it to prevent ordinary descendants from outliving the command.
+     */
+    terminateProcessTreeOnExit?: boolean;
+    /**
+     * Maximum combined stdout and stderr bytes retained when `capture` is true.
+     *
+     * @default 16777216
+     */
+    maxOutputBytes?: number;
 }
+/** @internal Exported so Windows tree-termination arguments can be tested on every host. */
+export declare function buildWindowsTaskkillArgs(pid: number, force: boolean): string[];
 /**
  * Run a command and return the result.
  * Works across Deno, Node.js, and Bun.

package/esm/src/platform/compat/process/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/command.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAyFD;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CA+LxB"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/command.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAuED,4FAA4F;AAC5F,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAK9E;AAoTD;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAmVxB"}