salmon-loop 0.2.3

package/dist/core/strata/checkpoint/snapshot-write-tree.js

@@ -0,0 +1,72 @@
+import { join } from 'path';
+import { stat } from '../../adapters/fs/node-fs.js';
+import { classifyGitFailureHint } from './snapshot-audit.js';
+export async function tryWriteTreeWithRetry(git, retryDelaysMs) {
+    let attempts = 0;
+    let lastError;
+    for (let i = 0; i <= retryDelaysMs.length; i += 1) {
+        attempts = i + 1;
+        try {
+            return { tree: (await git.query(['write-tree'])).trim(), attempts };
+        }
+        catch (error) {
+            lastError = error;
+            if (i >= retryDelaysMs.length)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, retryDelaysMs[i]));
+        }
+    }
+    throw Object.assign(lastError instanceof Error ? lastError : new Error('write-tree failed'), {
+        writeTreeAttempts: attempts,
+    });
+}
+export async function probeWriteTreeFailure(git) {
+    const details = {};
+    const indexLockPath = join(git.repoPath, '.git', 'index.lock');
+    try {
+        const lockStat = await stat(indexLockPath);
+        details.indexLockPresent = true;
+        details.indexLockAgeMs = Math.max(0, Math.floor(Date.now() - lockStat.mtimeMs));
+    }
+    catch {
+        details.indexLockPresent = false;
+    }
+    try {
+        const unmergedRaw = await git.exec(['ls-files', '-u'], { allowError: true });
+        const count = unmergedRaw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean).length;
+        details.unmergedCount = count;
+    }
+    catch {
+        details.unmergedCount = undefined;
+    }
+    try {
+        const insideMeta = await git.execMeta(['rev-parse', '--is-inside-work-tree']);
+        if (insideMeta.ok) {
+            details.isInsideWorkTree = insideMeta.stdout.toString('utf8').trim() === 'true';
+        }
+        else {
+            details.isInsideWorkTree = false;
+            details.spawnErrorCode =
+                typeof insideMeta.error?.code === 'string' ? insideMeta.error.code : undefined;
+            details.workTreeProbeErrorCode =
+                insideMeta.error?.code ||
+                    (typeof insideMeta.code === 'number' ? `EXIT_${insideMeta.code}` : undefined);
+            details.workTreeProbeHintCode = classifyGitFailureHint({
+                message: insideMeta.error?.message ||
+                    (typeof insideMeta.code === 'number'
+                        ? `rev-parse exited ${insideMeta.code}`
+                        : 'rev-parse failed'),
+                stderr: insideMeta.stderr,
+                command: 'rev-parse --is-inside-work-tree',
+            });
+        }
+    }
+    catch {
+        details.isInsideWorkTree = undefined;
+    }
+    return details;
+}
+//# sourceMappingURL=snapshot-write-tree.js.map

package/dist/core/strata/engine/shadow-merge-engine.js

@@ -0,0 +1,394 @@
+import path from 'path';
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { logIgnoredError } from '../../observability/ignored-error.js';
+import { getLogger } from '../../observability/logger.js';
+import { getRejectionsDir, getTmpDir } from '../../runtime/paths.js';
+import { normalizePath } from '../../utils/path.js';
+import { StrataContentGuardian } from '../interaction/content-guardian.js';
+import { StrataFileSystemProvider } from '../interaction/file-system-provider.js';
+export class ShadowMergeEngine {
+    options;
+    checkpoints;
+    sidecar;
+    gitAdapter;
+    guardian;
+    fsp;
+    constructor(options, checkpoints, sidecar) {
+        this.options = options;
+        this.checkpoints = checkpoints;
+        this.sidecar = sidecar ?? createNoopSidecar();
+        this.gitAdapter = new GitAdapter(options.mainRepoPath);
+        this.guardian = new StrataContentGuardian();
+        this.fsp = options.fileSystemProvider ?? new StrataFileSystemProvider(this.gitAdapter);
+    }
+    async apply() {
+        const { mainRepoPath, shadowWorktreePath, initialRef, latestRef } = this.options;
+        // L3: SyntheticSidecarLayer Injection
+        await this.sidecar.inject(shadowWorktreePath);
+        // Strategy Pattern Implementation
+        const strategy = this.options.applyBackOnDirty || 'abort';
+        // Check if workspace is dirty
+        const isDirty = await this.isWorkspaceDirty(mainRepoPath);
+        if (isDirty && strategy === 'abort') {
+            throw new Error(text.loop.workspaceDirtyAbort);
+        }
+        if (isDirty && strategy === '3way') {
+            getLogger().warn(text.loop.using3WayMergeStrategy);
+        }
+        // Zero Trust Workflow: Pre-Flight (Safety)
+        getLogger().debug('[ShadowMergeEngine] Creating snapshot for atomic transaction');
+        const snapshot = await this.checkpoints.createSafeSnapshot(mainRepoPath);
+        // T1: Dirty Transaction Backup (Captured early to satisfy Atomicity Contract and Unit Tests)
+        const t1BackupHash = await this.checkpoints.createDirtyBackup(mainRepoPath);
+        if (t1BackupHash) {
+            getLogger().debug(`[ShadowMergeEngine] Created T1 Dirty Backup: ${t1BackupHash}`);
+        }
+        try {
+            const diffEntries = await this.getShadowDiffEntries(shadowWorktreePath, initialRef, latestRef);
+            const operations = [];
+            for (const entry of diffEntries) {
+                if (entry.status === 'R' || entry.status === 'C') {
+                    if (entry.oldPath) {
+                        operations.push({ type: 'D', path: entry.oldPath });
+                    }
+                    operations.push({ type: 'A', path: entry.path });
+                    continue;
+                }
+                if (entry.status === 'A' || entry.status === 'M' || entry.status === 'D') {
+                    operations.push({ type: entry.status, path: entry.path });
+                }
+            }
+            if (operations.length === 0) {
+                return;
+            }
+            const conflicts = [];
+            const skipped = [];
+            const maxFileBytes = this.options.maxFileBytes ?? 1024 * 1024;
+            for (const op of operations) {
+                const policy = await this.shouldAllowPath(op.path);
+                if (!policy.allowed) {
+                    skipped.push(`${op.path} (${policy.reason})`);
+                    continue;
+                }
+                const status = await this.getStatusForPath(mainRepoPath, op.path);
+                const hasUserChanges = status
+                    ? status.staged || status.unstaged || status.untracked
+                    : false;
+                if (op.type === 'A') {
+                    const aiContent = await this.gitShowFile(shadowWorktreePath, latestRef, op.path);
+                    if (!aiContent) {
+                        skipped.push(`${op.path} (missing-ai)`);
+                        continue;
+                    }
+                    if (aiContent.length > maxFileBytes) {
+                        skipped.push(`${op.path} (size-limit)`);
+                        continue;
+                    }
+                    if (hasUserChanges) {
+                        const ignored = await this.isIgnoredPath(mainRepoPath, op.path);
+                        if (ignored) {
+                            const userWorkingPath = path.join(mainRepoPath, op.path);
+                            /**
+                             * 🛡️ CONTROLLED IO: Explicitly pass mainRepoPath as rootContext
+                             * to prevent AI-driven path traversal to system files.
+                             */
+                            const userWorkingContent = await this.fsp.readFileBufferSafe(userWorkingPath, mainRepoPath);
+                            if (userWorkingContent) {
+                                const isBinary = (await this.isBinaryPath(mainRepoPath, op.path, userWorkingContent)) ||
+                                    (await this.isBinaryPath(shadowWorktreePath, op.path, aiContent));
+                                if (isBinary) {
+                                    skipped.push(`${op.path} (binary)`);
+                                    continue;
+                                }
+                                const emptyBase = Buffer.alloc(0);
+                                getLogger().warn(text.loop.unionMergeWarning(op.path));
+                                const workingMerge = await this.mergeFileContents(mainRepoPath, emptyBase, userWorkingContent, aiContent, { union: true });
+                                await this.fsp.writeFile(userWorkingPath, workingMerge.merged, mainRepoPath);
+                                continue;
+                            }
+                        }
+                        conflicts.push(op.path);
+                        continue;
+                    }
+                    const destPath = path.join(mainRepoPath, op.path);
+                    try {
+                        await this.fsp.mkdir(path.dirname(destPath), { recursive: true }, mainRepoPath);
+                        await this.fsp.writeFile(destPath, aiContent, mainRepoPath);
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err?.code === 'EISDIR' || err?.code === 'EEXIST' || err?.code === 'ENOTDIR') {
+                            conflicts.push(`${op.path} (fs-collision)`);
+                            continue;
+                        }
+                        throw error;
+                    }
+                    continue;
+                }
+                if (op.type === 'D') {
+                    if (hasUserChanges) {
+                        conflicts.push(op.path);
+                        continue;
+                    }
+                    const targetPath = path.join(mainRepoPath, op.path);
+                    try {
+                        await this.fsp.unlink(targetPath, mainRepoPath);
+                    }
+                    catch (error) {
+                        const err = error;
+                        if (err?.code !== 'ENOENT') {
+                            throw error;
+                        }
+                    }
+                    continue;
+                }
+                // Merge logic
+                if (status?.deleted && !status?.untracked) {
+                    conflicts.push(op.path);
+                    continue;
+                }
+                if (status?.untracked) {
+                    const userWorkingPath = path.join(mainRepoPath, op.path);
+                    const userWorkingContent = await this.fsp.readFileBufferSafe(userWorkingPath, mainRepoPath);
+                    if (!userWorkingContent) {
+                        conflicts.push(op.path);
+                        continue;
+                    }
+                }
+                const baseContent = await this.getBaseContent(shadowWorktreePath, initialRef, op.path);
+                const aiContent = await this.gitShowFile(shadowWorktreePath, latestRef, op.path);
+                if (!baseContent || !aiContent) {
+                    conflicts.push(op.path);
+                    continue;
+                }
+                const userWorkingPath = path.join(mainRepoPath, op.path);
+                const userWorkingContent = await this.fsp.readFileBufferSafe(userWorkingPath, mainRepoPath);
+                if (!userWorkingContent) {
+                    conflicts.push(op.path);
+                    continue;
+                }
+                const isBinary = (await this.isBinaryPath(shadowWorktreePath, op.path, aiContent)) ||
+                    (await this.isBinaryPath(mainRepoPath, op.path, userWorkingContent));
+                if (isBinary) {
+                    skipped.push(`${op.path} (binary)`);
+                    continue;
+                }
+                const workingMerge = await this.mergeFileContents(mainRepoPath, baseContent, userWorkingContent, aiContent);
+                await this.fsp.writeFile(userWorkingPath, workingMerge.merged, mainRepoPath);
+                if (workingMerge.conflict) {
+                    conflicts.push(op.path);
+                }
+            }
+            if (skipped.length > 0) {
+                getLogger().warn(text.loop.skippedFiles(skipped.join(', ')));
+            }
+            if (conflicts.length > 0) {
+                const rejectionsDir = getRejectionsDir(mainRepoPath);
+                await this.fsp.mkdir(rejectionsDir, { recursive: true }, mainRepoPath);
+                for (const conflictPath of conflicts) {
+                    try {
+                        const aiContent = await this.gitShowFile(shadowWorktreePath, latestRef, conflictPath);
+                        if (aiContent) {
+                            const rejFullPath = path.join(rejectionsDir, `${conflictPath}.rej`);
+                            await this.fsp.mkdir(path.dirname(rejFullPath), { recursive: true }, mainRepoPath);
+                            await this.fsp.writeFile(rejFullPath, aiContent, mainRepoPath);
+                        }
+                    }
+                    catch (e) {
+                        getLogger().error(`Failed to generate rejection for ${conflictPath}: ${e}`);
+                    }
+                }
+                throw new Error(text.loop.applyBackCompletedWithConflicts(conflicts.length, conflicts.join(', ')));
+            }
+            getLogger().debug('[ShadowMergeEngine] Transaction completed successfully');
+        }
+        catch (error) {
+            getLogger().error(`[ShadowMergeEngine] Transaction failed, rolling back: ${error}`);
+            if (t1BackupHash) {
+                getLogger().debug(`[ShadowMergeEngine] T1 backup found (${t1BackupHash}), performing safe rollback.`);
+                await this.checkpoints.restoreDirtyBackup(mainRepoPath, t1BackupHash);
+            }
+            else if (!isDirty) {
+                getLogger().warn(`[ShadowMergeEngine] No T1 backup found in clean workspace rollback. Restoring T0 snapshot: ${snapshot.commitHash}`);
+                await this.checkpoints.restoreToMain(mainRepoPath, snapshot.commitHash, true);
+            }
+            else {
+                // If T1 backup is missing, restoring T0 can overwrite user dirty state.
+                // Do not perform automated restore in this branch.
+                getLogger().error(`[ShadowMergeEngine] CRITICAL: No T1 backup found during rollback. ` +
+                    `Skipping automated restore to prevent potential data loss. ` +
+                    `Please verify workspace state manually. Snapshot was: ${snapshot.commitHash}`);
+            }
+            throw error;
+        }
+    }
+    async shouldAllowPath(relativePath, contentSize) {
+        if (!this.options.shouldAllowPath)
+            return { allowed: true };
+        return this.options.shouldAllowPath(relativePath, contentSize);
+    }
+    async getBaseContent(worktreePath, ref, relativePath) {
+        const base = await this.gitShowFile(worktreePath, ref, relativePath);
+        if (base)
+            return base;
+        if (this.sidecar.has(relativePath)) {
+            return this.sidecar.get(relativePath);
+        }
+        return null;
+    }
+    async isBinaryPath(repoPath, relativePath, content) {
+        const ext = path.extname(relativePath).toLowerCase();
+        const binaryExtensions = [
+            '.png',
+            '.jpg',
+            '.jpeg',
+            '.gif',
+            '.bmp',
+            '.ico',
+            '.pdf',
+            '.zip',
+            '.tar',
+            '.gz',
+            '.7z',
+            '.exe',
+            '.dll',
+            '.so',
+            '.dylib',
+            '.bin',
+            '.dat',
+        ];
+        if (binaryExtensions.includes(ext))
+            return true;
+        if (content)
+            return this.guardian.inspect(content).isBinary;
+        try {
+            const filePath = path.join(repoPath, relativePath);
+            const buffer = await this.fsp.readFileBufferSafe(filePath, repoPath);
+            if (!buffer)
+                return false;
+            return this.guardian.inspect(buffer).isBinary;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isIgnoredPath(repoPath, relativePath) {
+        const normalized = normalizePath(relativePath);
+        return await this.gitAdapter.checkIgnore(normalized);
+    }
+    async gitShowFile(repoPath, ref, relativePath) {
+        const git = repoPath === this.options.mainRepoPath ? this.gitAdapter : new GitAdapter(repoPath);
+        try {
+            return await git.show(ref, relativePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    async mergeFileContents(repoPath, baseContent, userContent, aiContent, _options = {}) {
+        const { normalized: normBase } = this.guardian.inspect(baseContent);
+        const { normalized: normUser, eol: detectedEOL } = this.guardian.inspect(userContent);
+        const { normalized: normAi } = this.guardian.inspect(aiContent);
+        const finalTargetEOL = detectedEOL;
+        const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const tmpDir = getTmpDir(repoPath);
+        const basePath = path.join(tmpDir, `base-${suffix}`);
+        const userPath = path.join(tmpDir, `user-${suffix}`);
+        const aiPath = path.join(tmpDir, `ai-${suffix}`);
+        /**
+         * 🛡️ TMP FILES: Still within the repo sandbox for git merge-file
+         * but using atomic FSP to ensure cleanup and safety.
+         */
+        await this.fsp.mkdir(tmpDir, { recursive: true }, repoPath);
+        await this.fsp.writeFile(basePath, normBase, repoPath);
+        await this.fsp.writeFile(userPath, normUser, repoPath);
+        await this.fsp.writeFile(aiPath, normAi, repoPath);
+        try {
+            const result = await this.gitAdapter.mergeFile(basePath, userPath, aiPath, {
+                union: _options.union,
+            });
+            const mergedStr = result.content.toString('utf8');
+            const restoredBuffer = this.guardian.restore(mergedStr, finalTargetEOL);
+            return {
+                merged: restoredBuffer,
+                conflict: result.hasConflict,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`git merge-file failed: ${msg}`);
+        }
+        finally {
+            await this.fsp
+                .unlink(basePath, repoPath)
+                .catch((error) => logIgnoredError(`[ShadowMerge] cleanup ${basePath}`, error));
+            await this.fsp
+                .unlink(userPath, repoPath)
+                .catch((error) => logIgnoredError(`[ShadowMerge] cleanup ${userPath}`, error));
+            await this.fsp
+                .unlink(aiPath, repoPath)
+                .catch((error) => logIgnoredError(`[ShadowMerge] cleanup ${aiPath}`, error));
+        }
+    }
+    async getStatusForPath(repoPath, relativePath) {
+        const git = new GitAdapter(repoPath);
+        return await git.getStatusForPath(relativePath);
+    }
+    async getShadowDiffEntries(worktreePath, initialRef, latestRef) {
+        const git = new GitAdapter(worktreePath);
+        const output = await git.query(['diff', '--name-status', '-z', initialRef, latestRef]);
+        if (!output)
+            return [];
+        const tokens = output.split('\0').filter((token) => token.length > 0);
+        const entries = [];
+        for (let i = 0; i < tokens.length; i += 1) {
+            const statusToken = tokens[i];
+            const status = statusToken.charAt(0);
+            if (status === 'R' || status === 'C') {
+                const oldPath = tokens[i + 1];
+                const newPath = tokens[i + 2];
+                if (oldPath && newPath) {
+                    entries.push({
+                        status,
+                        path: normalizePath(newPath),
+                        oldPath: normalizePath(oldPath),
+                    });
+                }
+                i += 2;
+                continue;
+            }
+            const pathToken = tokens[i + 1];
+            if (pathToken) {
+                entries.push({ status, path: normalizePath(pathToken) });
+            }
+            i += 1;
+        }
+        return entries;
+    }
+    async isWorkspaceDirty(repoPath) {
+        try {
+            const git = new GitAdapter(repoPath);
+            const status = await git.query(['status', '--porcelain']);
+            return status.trim().length > 0;
+        }
+        catch (error) {
+            getLogger().error(`Failed to check workspace status: ${error}`);
+            return false;
+        }
+    }
+}
+function createNoopSidecar() {
+    return {
+        async capture() { },
+        async inject() { },
+        has() {
+            return false;
+        },
+        async get() {
+            return null;
+        },
+        async clear() { },
+    };
+}
+//# sourceMappingURL=shadow-merge-engine.js.map

package/dist/core/strata/index.js

@@ -0,0 +1,15 @@
+// Types
+export * from './types.js';
+// Checkpoint
+export * from './checkpoint/manager.js';
+// Engine
+// ShadowMergeEngineOptions is exported from types.js as well?
+// No, it is defined in engine/shadow-merge-engine.ts
+// If types.ts also exports it, we have conflict.
+// Let's check src/core/strata/types.ts
+export * from './engine/shadow-merge-engine.js';
+// Layers
+export * from './layers/worktree.js';
+export * from './layers/sidecar-layer.js';
+export * from './layers/immutable-git-layer.js';
+//# sourceMappingURL=index.js.map

package/dist/core/strata/interaction/content-guardian.js

@@ -0,0 +1,59 @@
+import { TextNormalizer } from '../../../utils/eol.js';
+import { LIMITS } from '../../config/limits.js';
+/**
+ * Strata Content Guardian
+ *
+ * Implements strict content safety protocols for Strata file interactions.
+ * - Binary Detection: Prevents corruption of binary files
+ * - EOL Normalization: Ensures cross-platform merge consistency
+ * - Size Guard: Prevents memory exhaustion attacks
+ */
+export class StrataContentGuardian {
+    static BINARY_CHECK_BYTES = LIMITS.binaryCheckBufferSize;
+    /**
+     * Sniff content for binary signatures and normalize text for processing.
+     * This is the entry point for ALL file content entering the Strata system.
+     */
+    inspect(content) {
+        const isBinary = this.hasBinarySignature(content);
+        const size = content.length;
+        if (isBinary) {
+            return {
+                normalized: '', // We do not normalize binary content
+                eol: '\n', // Default fallback
+                isBinary: true,
+                size,
+            };
+        }
+        // For text files, perform EOL sniffing and normalization
+        const textContent = content.toString('utf8');
+        const { normalized, eol } = TextNormalizer.read(textContent);
+        return {
+            normalized,
+            eol,
+            isBinary: false,
+            size,
+        };
+    }
+    /**
+     * Restore content to its original EOL format.
+     * Must be called before writing any merged content back to disk.
+     */
+    restore(text, targetEOL) {
+        const restoredText = TextNormalizer.restore(text, targetEOL);
+        return Buffer.from(restoredText, 'utf8');
+    }
+    /**
+     * Check for null bytes in the first N bytes of the buffer.
+     * This is the same heuristic used by Git.
+     */
+    hasBinarySignature(content) {
+        const len = Math.min(content.length, StrataContentGuardian.BINARY_CHECK_BYTES);
+        for (let i = 0; i < len; i++) {
+            if (content[i] === 0)
+                return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=content-guardian.js.map

package/dist/core/strata/interaction/file-system-provider.js

@@ -0,0 +1,89 @@
+import * as path from 'path';
+import { promises as fs } from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
+import { ensureInSandbox } from '../../utils/path.js';
+import { StrataContentGuardian } from './content-guardian.js';
+/**
+ * Strata File System Provider
+ *
+ * Implements the "Disk First" strategy for reading file content.
+ * 🛡️ SAFETY NOTE: All physical IO is protected by Sandbox checks to
+ * prevent unintended path traversal.
+ */
+export class StrataFileSystemProvider {
+    gitAdapter;
+    guardian;
+    constructor(gitAdapter) {
+        this.gitAdapter = gitAdapter;
+        this.guardian = new StrataContentGuardian();
+    }
+    /**
+     * Reads the "Yours" version of a file.
+     */
+    async readYours(repoPath, relativePath) {
+        // 🛡️ Guard: Ensure we don't leak files outside the targeted repository
+        const fullPath = ensureInSandbox(repoPath, path.join(repoPath, relativePath));
+        try {
+            getLogger().debug(`[StrataFileSystem] Reading 'Yours' content from disk: ${relativePath}`);
+            return await fs.readFile(fullPath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                getLogger().debug(`[StrataFileSystem] File not found on disk: ${relativePath}`);
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Reads a file as Buffer safely within a controlled root.
+     */
+    async readFileBufferSafe(filePath, rootContext) {
+        try {
+            const safePath = rootContext ? ensureInSandbox(rootContext, filePath) : filePath;
+            return await fs.readFile(safePath);
+        }
+        catch (error) {
+            const err = error;
+            if (err?.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    /**
+     * Writes content to a file with sandbox enforcement.
+     */
+    async writeFile(filePath, content, rootContext) {
+        const safePath = rootContext ? ensureInSandbox(rootContext, filePath) : filePath;
+        await fs.writeFile(safePath, content);
+    }
+    /**
+     * Creates a directory recursively with sandbox enforcement.
+     */
+    async mkdir(dirPath, options, rootContext) {
+        const safePath = rootContext ? ensureInSandbox(rootContext, dirPath) : dirPath;
+        await fs.mkdir(safePath, options);
+    }
+    /**
+     * Deletes a file with sandbox enforcement.
+     */
+    async unlink(filePath, rootContext) {
+        const safePath = rootContext ? ensureInSandbox(rootContext, filePath) : filePath;
+        await fs.unlink(safePath);
+    }
+    /**
+     * Checks if a file is binary with optional sandbox enforcement.
+     */
+    async isBinary(filePath, rootContext) {
+        try {
+            const safePath = rootContext ? ensureInSandbox(rootContext, filePath) : filePath;
+            const buffer = await fs.readFile(safePath);
+            return this.guardian.inspect(buffer).isBinary;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=file-system-provider.js.map