@veryfront/ext-content-mdx 0.1.1186 → 0.1.1189

package/esm/src/platform/adapters/runtime/shared/node-filesystem-adapter.js

@@ -0,0 +1,471 @@
+import { createFileWatcher, createWatcherIterator, setupNodeFsWatcher } from "./shared-watcher.js";
+import { makeNodeTempDir } from "./temp-dir.js";
+import { isProxyWithoutHooks } from "../../../compat/error-introspection.js";
+import { isCanonicalNotFoundError } from "../../../compat/not-found-error.js";
+import { readBoundedFilePrefix, readFileWithinLimit, withFileHandle, } from "../../bounded-file-read.js";
+import { markNativeFileSystemAdapter } from "../../native-file-system-provenance.js";
+import { constants as nodeFsConstants } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "../../../compat/path/index.js";
+import { FileSnapshotChangedError } from "../../file-snapshot-error.js";
+const silentLogger = {
+    error: () => { },
+    debug: () => { },
+};
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const reflectApply = Reflect.apply;
+function toSnapshotStat(stats) {
+    return {
+        dev: stats.dev,
+        ino: stats.ino,
+        size: stats.size,
+        mtimeNs: stats.mtimeNs,
+        ctimeNs: stats.ctimeNs,
+        isFile: () => stats.isFile(),
+        isSymbolicLink: () => stats.isSymbolicLink(),
+    };
+}
+const nodeFileSystemOperations = {
+    async realpath(path) {
+        const fs = await import("node:fs/promises");
+        return await fs.realpath(path);
+    },
+    async lstat(path) {
+        const fs = await import("node:fs/promises");
+        return toSnapshotStat(await fs.lstat(path, { bigint: true }));
+    },
+    async open(path, flags) {
+        const fs = await import("node:fs/promises");
+        const handle = await fs.open(path, flags);
+        return {
+            async stat() {
+                return toSnapshotStat(await handle.stat({ bigint: true }));
+            },
+            read(buffer, offset, length, position) {
+                return handle.read(buffer, offset, length, position);
+            },
+            writeFile(content) {
+                return handle.writeFile(content);
+            },
+            close() {
+                return handle.close();
+            },
+        };
+    },
+};
+function hasOwn(value, property) {
+    return Object.prototype.hasOwnProperty.call(value, property);
+}
+function isContainedPath(path, root) {
+    const relation = relative(root, path);
+    return relation === "" ||
+        (relation !== ".." && !relation.startsWith(`..${sep}`) && !isAbsolute(relation));
+}
+function requirePositiveSafeInteger(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError("Snapshot byte limit must be a positive safe integer");
+    }
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function sameGeneration(left, right) {
+    return sameIdentity(left, right) &&
+        left.size === right.size &&
+        left.mtimeNs === right.mtimeNs &&
+        left.ctimeNs === right.ctimeNs;
+}
+function changed(message, cause) {
+    const error = new FileSnapshotChangedError(message);
+    if (cause !== undefined) {
+        Object.defineProperty(error, "cause", { value: cause, configurable: true });
+    }
+    return error;
+}
+function hasOwnDataErrorCode(error, expected) {
+    if (typeof error !== "object" || error === null || isProxyWithoutHooks(error)) {
+        return false;
+    }
+    try {
+        const descriptor = getOwnPropertyDescriptor(error, "code");
+        return descriptor !== undefined &&
+            reflectApply(hasOwnProperty, descriptor, ["value"]) === true &&
+            descriptor.value === expected;
+    }
+    catch {
+        return false;
+    }
+}
+function throwSnapshotChangeForMissingPath(message, cause) {
+    if (isCanonicalNotFoundError(cause)) {
+        throw changed(message, cause);
+    }
+    throw cause;
+}
+function throwSnapshotChangeForPathRace(message, cause) {
+    if (hasOwnDataErrorCode(cause, "ELOOP")) {
+        throw changed(message, cause);
+    }
+    throwSnapshotChangeForMissingPath(message, cause);
+}
+async function readNodeFileSnapshotWithinLimit(operations, noFollow, path, containmentRoot, byteLimit) {
+    requirePositiveSafeInteger(byteLimit);
+    const lexicalRoot = resolve(containmentRoot);
+    const candidate = resolve(path);
+    if (!isContainedPath(candidate, lexicalRoot)) {
+        throw new TypeError("Snapshot path must be contained by the requested root");
+    }
+    const canonicalRoot = await operations.realpath(lexicalRoot);
+    const pathnameBefore = await operations.lstat(candidate);
+    if (pathnameBefore.isSymbolicLink()) {
+        throw new TypeError("Snapshot path must not be a symbolic link");
+    }
+    if (!pathnameBefore.isFile()) {
+        throw new TypeError("Snapshot path must identify a regular file");
+    }
+    return await withFileHandle(async () => {
+        try {
+            return await operations.open(candidate, nodeFsConstants.O_RDONLY | noFollow);
+        }
+        catch (cause) {
+            throwSnapshotChangeForPathRace("File identity became uncertain while opening the snapshot", cause);
+        }
+    }, async (handle) => {
+        let handleBefore;
+        try {
+            handleBefore = await handle.stat();
+        }
+        catch (cause) {
+            throwSnapshotChangeForMissingPath("Opened file identity could not be verified", cause);
+        }
+        if (!handleBefore.isFile() || !sameGeneration(pathnameBefore, handleBefore)) {
+            throw changed("File identity changed while opening the snapshot");
+        }
+        let canonicalTarget;
+        let pathnameOpened;
+        try {
+            [canonicalTarget, pathnameOpened] = await Promise.all([
+                operations.realpath(candidate),
+                operations.lstat(candidate),
+            ]);
+        }
+        catch (cause) {
+            throwSnapshotChangeForPathRace("File target became uncertain while opening the snapshot", cause);
+        }
+        if (pathnameOpened.isSymbolicLink() ||
+            !pathnameOpened.isFile() ||
+            !sameGeneration(handleBefore, pathnameOpened)) {
+            throw changed("File identity changed while opening the snapshot");
+        }
+        if (!isContainedPath(canonicalTarget, canonicalRoot)) {
+            throw new TypeError("Snapshot target must be contained by the canonical root");
+        }
+        if (handleBefore.size < 0n) {
+            throw changed("File size became uncertain while opening the snapshot");
+        }
+        if (handleBefore.size > BigInt(byteLimit)) {
+            throw new RangeError(`File exceeds byte limit of ${byteLimit} bytes`);
+        }
+        const size = Number(handleBefore.size);
+        let bytes;
+        try {
+            bytes = new Uint8Array(size);
+        }
+        catch (cause) {
+            throw new Error("Unable to allocate the admitted snapshot buffer", { cause });
+        }
+        let offset = 0;
+        while (offset < size) {
+            const { bytesRead } = await handle.read(bytes, offset, size - offset, offset);
+            if (!Number.isSafeInteger(bytesRead) || bytesRead <= 0 || bytesRead > size - offset) {
+                throw changed("File size changed while reading the snapshot");
+            }
+            offset += bytesRead;
+        }
+        let handleAfter;
+        let pathnameAfter;
+        let canonicalTargetAfter;
+        try {
+            handleAfter = await handle.stat();
+        }
+        catch (cause) {
+            throwSnapshotChangeForMissingPath("Opened file identity could not be verified after reading the snapshot", cause);
+        }
+        try {
+            [pathnameAfter, canonicalTargetAfter] = await Promise.all([
+                operations.lstat(candidate),
+                operations.realpath(candidate),
+            ]);
+        }
+        catch (cause) {
+            throwSnapshotChangeForPathRace("File identity became uncertain after reading the snapshot", cause);
+        }
+        if (!pathnameAfter.isFile() ||
+            pathnameAfter.isSymbolicLink() ||
+            !sameGeneration(handleBefore, handleAfter) ||
+            !sameGeneration(handleBefore, pathnameAfter) ||
+            canonicalTargetAfter !== canonicalTarget ||
+            !isContainedPath(canonicalTargetAfter, canonicalRoot)) {
+            throw changed("File snapshot changed during the read");
+        }
+        return bytes;
+    }, "Filesystem snapshot and handle cleanup both failed");
+}
+async function createNodeFileBytesExclusive(operations, path, content) {
+    await withFileHandle(() => operations.open(path, "wx"), (handle) => handle.writeFile(content), "Filesystem exclusive create and handle cleanup both failed");
+}
+/**
+ * Filesystem implementation shared by runtimes that provide Node-compatible
+ * `node:fs` APIs (currently Node.js and Bun).
+ */
+export class NodeCompatibleFileSystemAdapter {
+    logger;
+    constructor(logger = silentLogger, options = {}) {
+        this.logger = logger;
+        const operations = {
+            ...nodeFileSystemOperations,
+            ...options.operations,
+        };
+        const noFollow = hasOwn(options, "noFollow") ? options.noFollow : nodeFsConstants.O_NOFOLLOW;
+        if (typeof noFollow === "number" && noFollow !== 0) {
+            Object.defineProperty(this, "readFileSnapshotWithinLimit", {
+                value: (path, containmentRoot, byteLimit) => readNodeFileSnapshotWithinLimit(operations, noFollow, path, containmentRoot, byteLimit),
+                enumerable: true,
+            });
+        }
+        if (options.exclusiveCreate !== false) {
+            Object.defineProperty(this, "createFileBytesExclusive", {
+                value: (path, content) => createNodeFileBytesExclusive(operations, path, content),
+                enumerable: true,
+            });
+        }
+        if (globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta) === NodeCompatibleFileSystemAdapter) {
+            markNativeFileSystemAdapter(this);
+        }
+    }
+    async readFile(path) {
+        const fs = await import("node:fs/promises");
+        return fs.readFile(path, "utf-8");
+    }
+    async readFileBytes(path) {
+        const fs = await import("node:fs/promises");
+        const buffer = await fs.readFile(path);
+        return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    }
+    async readFileBytesBounded(path, byteLimit) {
+        const fs = await import("node:fs/promises");
+        return await readBoundedFilePrefix(async () => {
+            const handle = await fs.open(path, "r");
+            return {
+                close: () => handle.close(),
+                async read(buffer) {
+                    const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+                    return bytesRead === 0 ? null : bytesRead;
+                },
+            };
+        }, byteLimit);
+    }
+    async readFileBytesWithinLimit(path, byteLimit) {
+        const fs = await import("node:fs/promises");
+        return await readFileWithinLimit(async () => {
+            const handle = await fs.open(path, "r");
+            return {
+                close: () => handle.close(),
+                async read(buffer) {
+                    const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+                    return bytesRead === 0 ? null : bytesRead;
+                },
+            };
+        }, byteLimit);
+    }
+    async writeFile(path, content) {
+        const fs = await import("node:fs/promises");
+        await fs.writeFile(path, content, "utf-8");
+    }
+    async writeFileBytes(path, content) {
+        const fs = await import("node:fs/promises");
+        await fs.writeFile(path, content);
+    }
+    async rename(from, to) {
+        const fs = await import("node:fs/promises");
+        await fs.rename(from, to);
+    }
+    async exists(path) {
+        const fs = await import("node:fs/promises");
+        try {
+            await fs.access(path);
+            return true;
+        }
+        catch (error) {
+            if (isCanonicalNotFoundError(error))
+                return false;
+            throw error;
+        }
+    }
+    async *readDir(path) {
+        const fs = await import("node:fs/promises");
+        const entries = await fs.readdir(path, { withFileTypes: true });
+        for (const entry of entries) {
+            yield {
+                name: entry.name,
+                isFile: entry.isFile(),
+                isDirectory: entry.isDirectory(),
+                isSymlink: entry.isSymbolicLink(),
+            };
+        }
+    }
+    async stat(path) {
+        const fs = await import("node:fs/promises");
+        const stats = await fs.stat(path);
+        return {
+            size: stats.size,
+            isFile: stats.isFile(),
+            isDirectory: stats.isDirectory(),
+            isSymlink: stats.isSymbolicLink(),
+            mtime: stats.mtime,
+        };
+    }
+    async lstat(path) {
+        const fs = await import("node:fs/promises");
+        const stats = await fs.lstat(path);
+        return {
+            size: stats.size,
+            isFile: stats.isFile(),
+            isDirectory: stats.isDirectory(),
+            isSymlink: stats.isSymbolicLink(),
+            mtime: stats.mtime,
+        };
+    }
+    async realPath(path) {
+        const fs = await import("node:fs/promises");
+        return await fs.realpath(path);
+    }
+    async mkdir(path, options) {
+        const fs = await import("node:fs/promises");
+        await fs.mkdir(path, options);
+    }
+    async remove(path, options) {
+        const fs = await import("node:fs/promises");
+        await fs.rm(path, { recursive: options?.recursive, force: true });
+    }
+    async makeTempDir(prefix) {
+        return makeNodeTempDir(prefix);
+    }
+    setupWatcher(path, options) {
+        return setupNodeFsWatcher(path, options);
+    }
+    watch(paths, options) {
+        const pathArray = Array.isArray(paths) ? paths : [paths];
+        const recursive = options?.recursive ?? true;
+        const signal = options?.signal;
+        let closed = false;
+        const watchers = [];
+        const closedWatchers = new WeakSet();
+        const lifecycleFailures = [];
+        const pendingTasks = new Set();
+        const eventQueue = [];
+        let resolver = null;
+        let watcherFailure;
+        let closeWatcherGeneration = () => { };
+        let resolveClosed;
+        const closedSignal = new Promise((resolve) => {
+            resolveClosed = resolve;
+        });
+        const setResolver = (value) => {
+            resolver = value;
+        };
+        const trackTask = (task) => {
+            pendingTasks.add(task);
+            void task.then(() => pendingTasks.delete(task), () => pendingTasks.delete(task));
+        };
+        const recordLifecycleFailure = (failure) => {
+            const error = failure instanceof Error ? failure : new Error(String(failure));
+            if (!lifecycleFailures.includes(error))
+                lifecycleFailures.push(error);
+        };
+        const setupTasks = pathArray.map((path) => this.setupWatcher(path, {
+            recursive,
+            closed: () => closed,
+            signal,
+            eventQueue,
+            getResolver: () => resolver,
+            setResolver,
+            watchers,
+            trackTask,
+            onError: (error, watchPath) => {
+                this.logger.error(`File watcher error for ${watchPath}`, { error });
+                watcherFailure ??= error;
+                closeWatcherGeneration();
+            },
+        }));
+        const setup = Promise.all(setupTasks).then(() => undefined).catch((error) => {
+            closeWatcherGeneration();
+            throw error;
+        });
+        const iterator = createWatcherIterator(eventQueue, setResolver, () => closed, () => signal?.aborted ?? false);
+        const closeNativeWatchers = () => {
+            for (const watcher of watchers) {
+                if (closedWatchers.has(watcher))
+                    continue;
+                try {
+                    watcher.close();
+                    closedWatchers.add(watcher);
+                }
+                catch (error) {
+                    recordLifecycleFailure(error);
+                    this.logger.debug("Error closing file watcher during cleanup", { error });
+                }
+            }
+        };
+        const cleanup = () => {
+            if (closed)
+                return;
+            closed = true;
+            signal?.removeEventListener("abort", cleanup);
+            closeNativeWatchers();
+            resolver?.({ done: true, value: undefined });
+            resolver = null;
+            resolveClosed();
+        };
+        closeWatcherGeneration = cleanup;
+        if (signal?.aborted)
+            cleanup();
+        else
+            signal?.addEventListener("abort", cleanup, { once: true });
+        const watcher = createFileWatcher(iterator, cleanup);
+        watcher.ready = setup;
+        watcher.done = (async () => {
+            const [setupResult] = await Promise.allSettled([setup, closedSignal]);
+            if (setupResult.status === "rejected") {
+                recordLifecycleFailure(setupResult.reason);
+            }
+            // ready remains fail-fast, but lifecycle completion must join every
+            // root acquisition. Promise.all(setupTasks) can reject while a sibling
+            // lstat/readdir is still in flight.
+            const setupTaskResults = await Promise.allSettled(setupTasks);
+            for (const result of setupTaskResults) {
+                if (result.status === "rejected")
+                    recordLifecycleFailure(result.reason);
+            }
+            while (pendingTasks.size > 0) {
+                const results = await Promise.allSettled([...pendingTasks]);
+                for (const result of results) {
+                    if (result.status === "rejected")
+                        recordLifecycleFailure(result.reason);
+                }
+            }
+            // cleanup() already attempts this once. Retry any resource whose close()
+            // threw, but preserve every distinct failure so completion cannot be
+            // reported as clean after a partial teardown.
+            closeNativeWatchers();
+            if (watcherFailure)
+                recordLifecycleFailure(watcherFailure);
+            if (lifecycleFailures.length === 1)
+                throw lifecycleFailures[0];
+            if (lifecycleFailures.length > 1) {
+                throw new AggregateError(lifecycleFailures, "File watcher lifecycle did not complete cleanly");
+            }
+        })();
+        return watcher;
+    }
+}

package/esm/src/platform/adapters/runtime/shared/shared-watcher.d.ts

@@ -0,0 +1,16 @@
+import type { FileChangeEvent } from "../../base.js";
+import { createFileWatcher, createWatcherIterator, enqueueWatchEvent } from "./watcher-queue.js";
+export { createFileWatcher, createWatcherIterator, enqueueWatchEvent };
+interface NodeWatcherSetupOptions {
+    readonly recursive: boolean;
+    readonly closed: () => boolean;
+    readonly signal: AbortSignal | undefined;
+    readonly eventQueue: FileChangeEvent[];
+    readonly getResolver: () => ((value: IteratorResult<FileChangeEvent>) => void) | null;
+    readonly setResolver: (resolver: ((value: IteratorResult<FileChangeEvent>) => void) | null) => void;
+    readonly watchers: Array<import("node:fs").FSWatcher>;
+    readonly onError: (error: Error, path: string) => void;
+    readonly trackTask?: (task: Promise<void>) => void;
+}
+export declare function setupNodeFsWatcher(rootPath: string, options: NodeWatcherSetupOptions): Promise<void>;
+//# sourceMappingURL=shared-watcher.d.ts.map

package/esm/src/platform/adapters/runtime/shared/shared-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-watcher.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/shared/shared-watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEjG,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,CAAC;AAEvE,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,eAAe,EAAE,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACtF,QAAQ,CAAC,WAAW,EAAE,CACpB,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,KAChE,IAAI,CAAC;IACV,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,SAAS,EAAE,SAAS,CAAC,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;CACpD;AAWD,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAmJf"}

package/esm/src/platform/adapters/runtime/shared/shared-watcher.js

@@ -0,0 +1,140 @@
+import { createFileWatcher, createWatcherIterator, enqueueWatchEvent } from "./watcher-queue.js";
+export { createFileWatcher, createWatcherIterator, enqueueWatchEvent };
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function isRecursiveWatchUnsupported(error) {
+    const code = error.code;
+    return code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+}
+export async function setupNodeFsWatcher(rootPath, options) {
+    try {
+        const fs = await import("node:fs");
+        const fsPromises = await import("node:fs/promises");
+        const { isAbsolute, relative, resolve, sep } = await import("node:path");
+        const isClosed = () => options.closed() || options.signal?.aborted === true;
+        if (isClosed())
+            return;
+        let rootInfo;
+        try {
+            rootInfo = await fsPromises.lstat(rootPath);
+        }
+        catch (error) {
+            throw toError(error);
+        }
+        if (isClosed())
+            return;
+        const emit = (kind, watchedPath, filename) => {
+            const candidate = filename === null ? watchedPath : resolve(watchedPath, String(filename));
+            const pathFromRoot = relative(resolve(rootPath), candidate);
+            const eventPath = pathFromRoot === "" || (pathFromRoot !== ".." &&
+                !pathFromRoot.startsWith(`..${sep}`) &&
+                !isAbsolute(pathFromRoot))
+                ? candidate
+                : watchedPath;
+            enqueueWatchEvent({ kind, paths: [eventPath] }, options.eventQueue, options.getResolver, options.setResolver);
+            return eventPath;
+        };
+        const registerWatcher = (watchedPath, recursive, listener) => {
+            const watcher = fs.watch(watchedPath, { recursive, encoding: "utf8" }, listener);
+            watcher.on("error", (error) => {
+                if (!isClosed())
+                    options.onError(error, watchedPath);
+            });
+            if (isClosed()) {
+                watcher.close();
+                return watcher;
+            }
+            options.watchers.push(watcher);
+            return watcher;
+        };
+        if (options.recursive && rootInfo.isDirectory() && !rootInfo.isSymbolicLink()) {
+            try {
+                registerWatcher(rootPath, true, (eventType, filename) => {
+                    if (isClosed())
+                        return;
+                    emit(eventType === "change" ? "modify" : "any", rootPath, filename);
+                });
+                return;
+            }
+            catch (error) {
+                if (!isRecursiveWatchUnsupported(error))
+                    throw error;
+            }
+            // Compatible hosts and filesystems can reject recursive fs.watch.
+            // Maintain one non-recursive watcher per physical directory and
+            // reconcile the set whenever a directory entry is renamed.
+            const directoryWatchers = new Map();
+            let reconcileTail = Promise.resolve();
+            const removeSubtreeWatchers = (path) => {
+                const prefix = path.endsWith(sep) ? path : `${path}${sep}`;
+                for (const [directory, watcher] of directoryWatchers) {
+                    if (directory !== path && !directory.startsWith(prefix))
+                        continue;
+                    directoryWatchers.delete(directory);
+                    try {
+                        watcher.close();
+                    }
+                    catch (error) {
+                        if (!isClosed())
+                            options.onError(toError(error), directory);
+                    }
+                }
+            };
+            const watchDirectoryTree = async (path) => {
+                if (isClosed() || directoryWatchers.has(path))
+                    return;
+                let info;
+                try {
+                    info = await fsPromises.lstat(path);
+                }
+                catch (error) {
+                    if (error.code === "ENOENT") {
+                        removeSubtreeWatchers(path);
+                        return;
+                    }
+                    throw error;
+                }
+                if (!info.isDirectory() || info.isSymbolicLink() || isClosed())
+                    return;
+                const watcher = registerWatcher(path, false, (eventType, filename) => {
+                    if (isClosed())
+                        return;
+                    const changedPath = emit(eventType === "change" ? "modify" : "any", path, filename);
+                    if (eventType !== "rename")
+                        return;
+                    reconcileTail = reconcileTail
+                        .then(() => watchDirectoryTree(changedPath))
+                        .catch((error) => {
+                        if (!isClosed())
+                            options.onError(toError(error), changedPath);
+                    });
+                    options.trackTask?.(reconcileTail);
+                });
+                directoryWatchers.set(path, watcher);
+                watcher.once("close", () => {
+                    if (directoryWatchers.get(path) === watcher)
+                        directoryWatchers.delete(path);
+                });
+                const entries = await fsPromises.readdir(path, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (isClosed())
+                        return;
+                    if (entry.isDirectory() && !entry.isSymbolicLink()) {
+                        await watchDirectoryTree(resolve(path, entry.name));
+                    }
+                }
+            };
+            await watchDirectoryTree(resolve(rootPath));
+            return;
+        }
+        registerWatcher(rootPath, false, (eventType, filename) => {
+            if (isClosed())
+                return;
+            emit(eventType === "change" ? "modify" : "any", rootPath, filename);
+        });
+    }
+    catch (error) {
+        throw toError(error);
+    }
+}

package/esm/src/platform/adapters/runtime/shared/temp-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function makeNodeTempDir(prefix: string): Promise<string>;
+//# sourceMappingURL=temp-dir.d.ts.map

package/esm/src/platform/adapters/runtime/shared/temp-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temp-dir.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/shared/temp-dir.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQrE"}

package/esm/src/platform/adapters/runtime/shared/temp-dir.js

@@ -0,0 +1,10 @@
+import { validateTempDirectoryPrefix } from "../../../compat/temp-directory-prefix.js";
+export async function makeNodeTempDir(prefix) {
+    const validatedPrefix = validateTempDirectoryPrefix(prefix);
+    const { mkdtemp } = await import("node:fs/promises");
+    const { sep } = await import("node:path");
+    const { tmpdir } = await import("node:os");
+    const tempRoot = tmpdir();
+    const rootPrefix = tempRoot.endsWith(sep) ? tempRoot : `${tempRoot}${sep}`;
+    return await mkdtemp(`${rootPrefix}${validatedPrefix}`);
+}

package/esm/src/platform/adapters/runtime/shared/watcher-queue.d.ts

@@ -0,0 +1,5 @@
+import type { FileChangeEvent, FileWatcher } from "../../base.js";
+export declare function createWatcherIterator(eventQueue: FileChangeEvent[], setResolver: (r: ((value: IteratorResult<FileChangeEvent>) => void) | null) => void, isClosed: () => boolean, isAborted: () => boolean): AsyncIterator<FileChangeEvent>;
+export declare function enqueueWatchEvent(event: FileChangeEvent, eventQueue: FileChangeEvent[], getResolver: () => ((value: IteratorResult<FileChangeEvent>) => void) | null, setResolver: (resolver: ((value: IteratorResult<FileChangeEvent>) => void) | null) => void): void;
+export declare function createFileWatcher(iterator: AsyncIterator<FileChangeEvent>, cleanup: () => void): FileWatcher;
+//# sourceMappingURL=watcher-queue.d.ts.map

package/esm/src/platform/adapters/runtime/shared/watcher-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher-queue.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/shared/watcher-queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAElE,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,eAAe,EAAE,EAC7B,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,KAAK,IAAI,EACnF,QAAQ,EAAE,MAAM,OAAO,EACvB,SAAS,EAAE,MAAM,OAAO,GACvB,aAAa,CAAC,eAAe,CAAC,CAyChC;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,eAAe,EACtB,UAAU,EAAE,eAAe,EAAE,EAC7B,WAAW,EAAE,MAAM,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,EAC5E,WAAW,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,KAAK,IAAI,GACzF,IAAI,CASN;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,EACxC,OAAO,EAAE,MAAM,IAAI,GAClB,WAAW,CA2Bb"}