@veryfront/ext-content-mdx 0.1.1186 → 0.1.1189

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

@@ -1,9 +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 { readNodeFileSnapshotWithinLimit, supportsNativeFileSnapshots, } from "../adapters/runtime/shared/native-file-capabilities.js";
-export { isNotFoundError } from "./not-found-error.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.
  *
@@ -16,9 +52,6 @@ function denoGlobal() {
     return dntShim.dntGlobalThis.Deno;
 }
 class NodeFileSystem {
-    readFileSnapshotWithinLimit = supportsNativeFileSnapshots()
-        ? (path, containmentRoot, byteLimit) => readNodeFileSnapshotWithinLimit(path, containmentRoot, byteLimit)
-        : undefined;
     fs;
     os;
     path;
@@ -72,10 +105,7 @@ class NodeFileSystem {
             const handle = await this.getFs().open(path, "r");
             return {
                 close: () => handle.close(),
-                read: async (buffer) => {
-                    const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
-                    return bytesRead === 0 ? null : bytesRead;
-                },
+                read: async (buffer) => (await handle.read(buffer)).bytesRead,
             };
         }, byteLimit);
     }
@@ -87,10 +117,6 @@ class NodeFileSystem {
         await this.ensureInitialized();
         await this.getFs().writeFile(path, data);
     }
-    async createFileBytesExclusive(path, data) {
-        await this.ensureInitialized();
-        await this.getFs().writeFile(path, data, { flag: "wx" });
-    }
     async rename(from, to) {
         await this.ensureInitialized();
         await this.getFs().rename(from, to);
@@ -102,7 +128,7 @@ class NodeFileSystem {
             return true;
         }
         catch (error) {
-            if (error?.code === "ENOENT")
+            if (isNotFoundError(error))
                 return false;
             throw error;
         }
@@ -148,30 +174,30 @@ 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;
         }
     }
 }
 class DenoFileSystem {
-    readFileSnapshotWithinLimit = supportsNativeFileSnapshots()
-        ? (path, containmentRoot, byteLimit) => readNodeFileSnapshotWithinLimit(path, containmentRoot, byteLimit)
-        : undefined;
     readTextFile(path) {
         return denoGlobal().readTextFile(path);
     }
@@ -181,7 +207,10 @@ class DenoFileSystem {
     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) };
+            return {
+                close: () => file.close(),
+                read: (buffer) => file.read(buffer),
+            };
         }, byteLimit);
     }
     async writeTextFile(path, data) {
@@ -190,22 +219,6 @@ class DenoFileSystem {
     async writeFile(path, data) {
         await denoGlobal().writeFile(path, data);
     }
-    async createFileBytesExclusive(path, data) {
-        const file = await denoGlobal().open(path, { write: true, createNew: true });
-        let offset = 0;
-        try {
-            while (offset < data.byteLength) {
-                const written = await file.write(data.subarray(offset));
-                if (!Number.isSafeInteger(written) || written <= 0 || written > data.byteLength - offset) {
-                    throw new Error("Deno exclusive create write made no forward progress");
-                }
-                offset += written;
-            }
-        }
-        finally {
-            file.close();
-        }
-    }
     async rename(from, to) {
         await denoGlobal().rename(from, to);
     }
@@ -215,7 +228,7 @@ class DenoFileSystem {
             return true;
         }
         catch (error) {
-            if (error instanceof denoGlobal().errors.NotFound)
+            if (isNotFoundError(error))
                 return false;
             throw error;
         }
@@ -256,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() {
@@ -293,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);
 }
@@ -323,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);
 }
@@ -335,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);
 }
@@ -365,8 +423,16 @@ export async function realPath(path) {
 }
 /** 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";
+    if (typeof error !== "object" || error === null || isProxyWithoutHooks(error)) {
+        return false;
+    }
+    try {
+        const AlreadyExists = isDeno ? denoGlobal().errors.AlreadyExists : undefined;
+        if (AlreadyExists && error instanceof AlreadyExists)
+            return true;
+        return hasOwnDataValue(error, "code", "EEXIST");
+    }
+    catch {
+        return false;
+    }
 }

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

@@ -1,7 +1,12 @@
 /**
- * Return whether an error or its 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.
+ * 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

@@ -1 +1 @@
-{"version":3,"file":"not-found-error.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/not-found-error.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,GAAG,CAAC,OAAO,CAAa,GAAG,OAAO,CAuCvF"}
+{"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

@@ -1,41 +1,174 @@
 import * as dntShim from "../../../_dnt.shims.js";
+import { isNativeErrorWithoutHooks, isProxyWithoutHooks, readNativeErrorNameWithoutHooks, } from "./error-introspection.js";
 import { isDeno } from "./runtime.js";
-/**
- * Return whether an error or its 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.
- */
-export function isNotFoundError(error, seen = new Set()) {
-    if (seen.has(error))
-        return false;
-    seen.add(error);
+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 NotFound = dntShim.dntGlobalThis.Deno?.errors?.NotFound;
-        if (isDeno && NotFound && error instanceof NotFound)
+        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;
-        const code = error?.code;
+    }
+    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 (error instanceof Error) {
-            if (error.name === "VeryfrontError" &&
-                error.slug === "file-not-found") {
-                return true;
-            }
-            const legacyContext = error.context;
-            if (error.name === "VeryfrontError[file]" &&
-                typeof legacyContext === "object" &&
-                legacyContext !== null &&
-                legacyContext.type === "file" &&
-                typeof legacyContext.message === "string" &&
-                /^(?:File|Path) not found:/.test(legacyContext.message)) {
-                return true;
-            }
-            if ("cause" in error)
-                return isNotFoundError(error.cause, seen);
+        if (!isNativeErrorWithoutHooks(current))
+            return false;
+        if (denoNotFoundPrototype && inheritsFrom(current, denoNotFoundPrototype)) {
+            return true;
         }
-    }
-    catch {
-        // Error classifiers must not replace the original filesystem failure.
+        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) {