@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/commands/diff-patch/unified.js

@@ -1,386 +1,2 @@
-import { byteLength } from "../../byte-encoding.js";
-import { Budget, ToolError, integer } from "./shared.js";
-import { decodeHeaderPath, isEpochHeader } from "./patch-path.js";
-function header(line, prefix) {
-    if (!line.startsWith(prefix))
-        throw new ToolError(`expected ${prefix.trim()} file header`);
-    const path = decodeHeaderPath(line.slice(prefix.length));
-    if (!path || /[\0\r\n]/u.test(path))
-        throw new ToolError("unsupported or empty patch filename");
-    return path;
-}
-export function startIndex(start, count) { return count === 0 ? start : start - 1; }
-export async function parseUnified(text, budget) {
-    if (text && !text.endsWith("\n"))
-        throw new ToolError("patch is truncated: missing final LF");
-    return parseUnifiedReader({ lines: budget.split(text).map(line => line.slice(0, -1)), index: 0 }, budget, false);
-}
-export async function parseUnifiedSection(cursor, budget) {
-    return parseUnifiedReader(cursor, budget, true);
-}
-async function parseUnifiedReader(cursor, budget, single) {
-    const physical = cursor.lines;
-    const patches = [];
-    let index = cursor.index;
-    let pendingMetadata = false;
-    while (index < physical.length) {
-        budget.step();
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-        const line = physical[index];
-        if (line === "") {
-            index++;
-            continue;
-        }
-        if (/^diff (?:--git |-[^ ]+ )/u.test(line) || /^index [0-9a-f]+\.\.[0-9a-f]+(?: 100(?:644|755))?$/u.test(line)
-            || /^(?:new file|deleted file) mode 100(?:644|755)$/u.test(line)) {
-            pendingMetadata = true;
-            index++;
-            continue;
-        }
-        const oldPath = header(line, "--- ");
-        const oldHeader = line.slice(4);
-        const oldEpoch = isEpochHeader(line);
-        const newPath = header(physical[++index] ?? "", "+++ ");
-        const newHeader = physical[index].slice(4);
-        const newEpoch = isEpochHeader(physical[index]);
-        index++;
-        budget.file();
-        const hunks = [];
-        let oldEnded = false;
-        let newEnded = false;
-        while (index < physical.length && physical[index].startsWith("@@")) {
-            budget.hunk();
-            const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@( .*)?$/u.exec(physical[index++]);
-            if (!match)
-                throw new ToolError("malformed unified hunk header");
-            const oldStart = integer(match[1], "old start");
-            const oldCount = integer(match[2] ?? "1", "old count");
-            const newStart = integer(match[3], "new start");
-            const newCount = integer(match[4] ?? "1", "new count");
-            for (const value of [oldStart, oldCount, newStart, newCount]) {
-                if (value > budget.limits.maxLines)
-                    throw new ToolError("hunk coordinate exceeds line limit");
-            }
-            if ((oldCount > 0 && oldStart === 0) || (newCount > 0 && newStart === 0) || (!oldCount && !newCount))
-                throw new ToolError("invalid zero hunk range");
-            if ((oldEnded && oldCount) || (newEnded && newCount))
-                throw new ToolError("hunk follows an incomplete final line");
-            let oldRead = 0;
-            let newRead = 0;
-            const lines = [];
-            let changed = false;
-            while (oldRead < oldCount || newRead < newCount) {
-                budget.step();
-                {
-                    const c = budget.checkpoint();
-                    if (c)
-                        await c;
-                }
-                const body = physical[index++];
-                const kind = body === "" ? " " : body?.[0];
-                if (body === undefined || (kind !== " " && kind !== "+" && kind !== "-"))
-                    throw new ToolError("truncated or malformed hunk body");
-                if ((kind !== "+" && oldEnded) || (kind !== "-" && newEnded))
-                    throw new ToolError("content follows an incomplete final line");
-                if (kind !== "+")
-                    oldRead++;
-                if (kind !== "-")
-                    newRead++;
-                if (oldRead > oldCount || newRead > newCount)
-                    throw new ToolError("hunk line counts do not match header");
-                const entry = { kind, text: `${body.slice(1)}\n` };
-                lines.push(entry);
-                changed ||= kind !== " ";
-                if (physical[index] === "\") {
-                    if (entry.text === "\n")
-                        throw new ToolError("empty incomplete line is not a valid text line");
-                    index++;
-                    entry.text = entry.text.slice(0, -1);
-                    if (kind !== "+")
-                        oldEnded = true;
-                    if (kind !== "-")
-                        newEnded = true;
-                }
-            }
-            if (!changed)
-                throw new ToolError("hunk has no changes");
-            hunks.push({ oldStart, oldCount, newStart, newCount, lines, section: match[5] ?? "" });
-        }
-        if (!hunks.length)
-            throw new ToolError("file patch has no hunks");
-        patches.push({ oldPath, newPath, oldEpoch, newEpoch, oldHeader, newHeader, hunks });
-        pendingMetadata = false;
-        if (single)
-            break;
-    }
-    if (pendingMetadata)
-        throw new ToolError("metadata without a file patch");
-    cursor.index = index;
-    return patches;
-}
-export function reversePatch(patch) {
-    return {
-        ...patch,
-        oldPath: patch.newPath, newPath: patch.oldPath,
-        oldEpoch: patch.newEpoch, newEpoch: patch.oldEpoch,
-        hunks: patch.hunks.map(hunk => ({
-            ...hunk,
-            oldStart: hunk.newStart, oldCount: hunk.newCount, newStart: hunk.oldStart, newCount: hunk.oldCount,
-            lines: hunk.lines.map(line => ({ kind: line.kind === "+" ? "-" : line.kind === "-" ? "+" : " ", text: line.text })),
-        })),
-    };
-}
-export async function applyHunks(original, patch, fuzz, budget, ignoreWhitespace = false, application = {}) {
-    const source = budget.split(original);
-    const result = [];
-    let resultBytes = 0;
-    const append = (line) => {
-        resultBytes += byteLength(line);
-        if (resultBytes > budget.limits.maxOutputBytes)
-            throw new ToolError("output byte limit exceeded");
-        result.push(line);
-    };
-    let cursor = 0;
-    let offset = 0;
-    let outputOffset = 0;
-    for (const [hunkIndex, hunk] of patch.hunks.entries()) {
-        budget.step();
-        const oldLines = hunk.lines.filter(line => line.kind !== "+");
-        let leading = 0;
-        let trailing = 0;
-        while (leading < hunk.lines.length && hunk.lines[leading].kind === " ")
-            leading++;
-        while (trailing < hunk.lines.length - leading && hunk.lines[hunk.lines.length - trailing - 1].kind === " ")
-            trailing++;
-        const expected = startIndex(hunk.oldStart, hunk.oldCount) + offset;
-        let found = -1;
-        let misordered = false;
-        let usedFuzz = 0;
-        const context = Math.max(leading, trailing);
-        const matches = async (position, prefixFuzz, suffixFuzz) => {
-            budget.step();
-            {
-                const c = budget.checkpoint();
-                if (c)
-                    await c;
-            }
-            if (position < 0 || position > source.length - hunk.oldCount + suffixFuzz)
-                return false;
-            for (let lineIndex = 0; lineIndex < oldLines.length; lineIndex++) {
-                if (lineIndex < prefixFuzz || lineIndex >= oldLines.length - suffixFuzz)
-                    continue;
-                const actual = source[position + lineIndex];
-                if (actual === undefined)
-                    return false;
-                const expectedLine = oldLines[lineIndex].text;
-                if (ignoreWhitespace)
-                    budget.step(actual.length + expectedLine.length);
-                if (!budget.equal(ignoreWhitespace ? actual.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : actual, ignoreWhitespace ? expectedLine.replace(/[ \t]+(?=\r?\n|$)/gu, "").replace(/[ \t]+/gu, " ") : expectedLine))
-                    return false;
-                {
-                    const c = budget.checkpoint();
-                    if (c)
-                        await c;
-                }
-            }
-            if (position < cursor)
-                misordered = true;
-            return true;
-        };
-        let matchedPrefixFuzz = 0;
-        let matchedSuffixFuzz = 0;
-        for (let tolerance = 0; tolerance <= Math.min(fuzz, context); tolerance++) {
-            if (application.rejectAll)
-                break;
-            usedFuzz = tolerance;
-            const prefixFuzz = tolerance + leading - context;
-            const suffixFuzz = tolerance + trailing - context;
-            if (prefixFuzz < 0 && hunk.oldStart <= 1) {
-                if (await matches(0, 0, suffixFuzz)) {
-                    found = 0;
-                    matchedPrefixFuzz = 0;
-                    matchedSuffixFuzz = suffixFuzz;
-                }
-                if (found >= 0)
-                    break;
-                continue;
-            }
-            if (suffixFuzz < 0) {
-                const end = source.length - hunk.oldCount;
-                if (await matches(end, Math.max(0, prefixFuzz), 0)) {
-                    found = end;
-                    matchedPrefixFuzz = Math.max(0, prefixFuzz);
-                    matchedSuffixFuzz = 0;
-                }
-                if (found >= 0)
-                    break;
-                continue;
-            }
-            const retained = oldLines.length - Math.max(0, prefixFuzz) - suffixFuzz;
-            if (retained === 0) {
-                if (await matches(expected, Math.max(0, prefixFuzz), suffixFuzz)) {
-                    found = expected;
-                    matchedPrefixFuzz = Math.max(0, prefixFuzz);
-                    matchedSuffixFuzz = suffixFuzz;
-                    break;
-                }
-                continue;
-            }
-            const maximum = source.length - hunk.oldCount + suffixFuzz;
-            const positiveLimit = maximum - expected;
-            const negativeLimit = Math.min(expected - cursor, expected);
-            const distanceLimit = Math.max(positiveLimit, negativeLimit);
-            const firstDistance = positiveLimit < 0 ? -positiveLimit : negativeLimit < 0 ? negativeLimit : 0;
-            for (let distance = firstDistance; distance <= distanceLimit; distance++) {
-                if (distance <= positiveLimit && await matches(expected + distance, Math.max(0, prefixFuzz), suffixFuzz)) {
-                    found = expected + distance;
-                    matchedPrefixFuzz = Math.max(0, prefixFuzz);
-                    matchedSuffixFuzz = suffixFuzz;
-                    break;
-                }
-                if (distance <= negativeLimit && await matches(expected - distance, Math.max(0, prefixFuzz), suffixFuzz)) {
-                    found = expected - distance;
-                    matchedPrefixFuzz = Math.max(0, prefixFuzz);
-                    matchedSuffixFuzz = suffixFuzz;
-                    break;
-                }
-            }
-            if (found >= 0)
-                break;
-        }
-        const matched = found;
-        if (matched >= 0)
-            offset = matched - startIndex(hunk.oldStart, hunk.oldCount);
-        if (misordered)
-            found = -1;
-        application.outcomes?.push({ hunk, index: hunkIndex + 1, failed: found < 0, misordered: found < 0 && misordered,
-            line: (matched < 0 ? startIndex(hunk.oldStart, hunk.oldCount) : matched) + 1 + outputOffset,
-            outputOffset, offset: matched - startIndex(hunk.oldStart, hunk.oldCount), fuzz: usedFuzz });
-        if (found < 0 && application.merge && !misordered) {
-            const position = Math.max(cursor, Math.min(source.length, expected));
-            while (cursor < position)
-                append(source[cursor++]);
-            let local = source.slice(cursor, cursor + hunk.oldCount);
-            // Without an original anchor GNU inserts the conflict before local text.
-            if (!oldLines.some((line, index) => budget.equal(line.text, local[index] ?? "")))
-                local = [];
-            const incoming = hunk.lines.filter(line => line.kind !== "-").map(line => line.text);
-            const base = oldLines.map(line => line.text);
-            let prefix = 0;
-            let suffix = 0;
-            while (prefix < Math.min(local.length, incoming.length, base.length)
-                && local[prefix] === incoming[prefix] && local[prefix] === base[prefix])
-                prefix++;
-            while (suffix < Math.min(local.length, incoming.length, base.length) - prefix
-                && local[local.length - suffix - 1] === incoming[incoming.length - suffix - 1]
-                && local[local.length - suffix - 1] === base[base.length - suffix - 1])
-                suffix++;
-            budget.step(local.join("").length + incoming.join("").length + base.join("").length);
-            {
-                const c = budget.checkpoint();
-                if (c)
-                    await c;
-            }
-            for (const line of local.slice(0, prefix))
-                append(line);
-            const mergeStart = result.length + 1;
-            // An already applied hunk is a clean merge, not a reversal.
-            if (local.join("") === incoming.join("")) {
-                const last = application.outcomes?.pop();
-                if (last)
-                    application.outcomes.push({ ...last, failed: false, fuzz: 0, offset: position - startIndex(hunk.oldStart, hunk.oldCount) });
-                for (const line of local.slice(prefix, local.length - suffix))
-                    append(line);
-            }
-            else {
-                append("<<<<<<<\n");
-                for (const line of local.slice(prefix, local.length - suffix))
-                    append(line);
-                if (application.merge === "diff3") {
-                    append("|||||||\n");
-                    for (const line of base.slice(prefix, base.length - suffix))
-                        append(line);
-                }
-                append("=======\n");
-                for (const line of incoming.slice(prefix, incoming.length - suffix))
-                    append(line);
-                append(">>>>>>>\n");
-                const last = application.outcomes?.pop();
-                if (last)
-                    application.outcomes.push({ ...last, mergeRange: [mergeStart, result.length] });
-            }
-            for (const line of local.slice(local.length - suffix))
-                append(line);
-            cursor += local.length;
-            outputOffset = result.length - cursor;
-            continue;
-        }
-        if (found < 0) {
-            if (application.partial)
-                continue;
-            throw new ToolError(`hunk ${hunkIndex + 1} does not match ${patch.oldPath}`, 1);
-        }
-        while (cursor < found + matchedPrefixFuzz)
-            append(source[cursor++]);
-        let removed = [];
-        let added = [];
-        const flush = () => {
-            if (!removed.length && !added.length)
-                return;
-            if (application.ifdef) {
-                append(`#${removed.length ? "ifndef" : "ifdef"} ${application.ifdef}\n`);
-                for (const text of removed)
-                    append(text);
-                if (removed.length && added.length)
-                    append("#else\n");
-                for (const text of added)
-                    append(text);
-                append("#endif\n");
-            }
-            else
-                for (const text of added)
-                    append(text);
-            removed = [];
-            added = [];
-        };
-        for (const line of hunk.lines.slice(matchedPrefixFuzz, hunk.lines.length - matchedSuffixFuzz)) {
-            if (line.kind === "+")
-                added.push(line.text);
-            else if (line.kind === " ") {
-                flush();
-                if (cursor < source.length)
-                    append(source[cursor++]);
-            }
-            else {
-                removed.push(source[cursor] ?? line.text);
-                cursor++;
-            }
-        }
-        flush();
-        outputOffset = result.length - cursor;
-    }
-    while (cursor < source.length)
-        append(source[cursor++]);
-    for (let index = 0; index < result.length - 1; index++) {
-        budget.step();
-        if (!result[index].endsWith("\n")) {
-            // An incomplete patch record only stays unterminated at the target EOF.
-            if (++resultBytes > budget.limits.maxOutputBytes)
-                throw new ToolError("output byte limit exceeded");
-            result[index] += "\n";
-        }
-        {
-            const c = budget.checkpoint();
-            if (c)
-                await c;
-        }
-    }
-    const text = result.join("");
-    budget.output(text);
-    return text;
-}
+export * from "../../../safe-bash-command-patch/unified.js";
 //# sourceMappingURL=unified.js.map

package/dist/safe-bash/commands/directory-admission.d.ts

@@ -1,4 +1,2 @@
-import { type CommandContext, type DirectoryEntry } from "../contracts/index.js";
-export declare function createDirectoryReader(maxEntries?: number): (context: CommandContext, path: string, ordered?: boolean) => Promise<DirectoryEntry[]>;
-export type DirectoryReader = ReturnType<typeof createDirectoryReader>;
+export * from "../../safe-bash-io-engine/commands/directory-admission.js";
 //# sourceMappingURL=directory-admission.d.ts.map

package/dist/safe-bash/commands/directory-admission.js

@@ -1,27 +1,2 @@
-import { FsError } from "../contracts/index.js";
-import { yieldTurn } from "../contracts/yield.js";
-export function createDirectoryReader(maxEntries = Infinity) {
-    if (maxEntries !== Infinity && (!Number.isSafeInteger(maxEntries) || maxEntries < 0)) {
-        throw new RangeError("maxDirectoryEntries must be a nonnegative safe integer or Infinity");
-    }
-    return async (context, path, ordered = false) => {
-        context.signal.throwIfAborted();
-        const entries = await context.fs.readdir(path, { signal: context.signal, ...(maxEntries === Infinity ? {} : { maxEntries }) });
-        context.signal.throwIfAborted();
-        if (entries.length > maxEntries) {
-            throw new FsError("EFBIG", { syscall: "readdir", path, message: "directory entry limit exceeded" });
-        }
-        await yieldTurn(context.signal);
-        if (ordered) {
-            for (let index = 1; index < entries.length; index++) {
-                if (index % 256 === 0)
-                    await yieldTurn(context.signal);
-                if (entries[index - 1].name > entries[index].name) {
-                    return entries.slice().sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
-                }
-            }
-        }
-        return entries;
-    };
-}
+export * from "../../safe-bash-io-engine/commands/directory-admission.js";
 //# sourceMappingURL=directory-admission.js.map

package/dist/safe-bash/commands/find/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-find/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/find/index.js

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-find/index.js";
+//# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/find-format.d.ts

@@ -1,21 +1,2 @@
-import { type CommandContext, type FileStat } from "../contracts/index.js";
-import { type ShellValue } from "../contracts/value.js";
-export interface FindFormatEntry {
-    readonly display: string;
-    readonly root: string;
-    readonly relative: string;
-    readonly depth: number;
-    readonly stat: FileStat;
-}
-/** Cooperative formatting and bounded output batches across all matched entries. */
-export declare class FindFormatBudget {
-    readonly context: CommandContext;
-    private untilYield;
-    constructor(context: CommandContext);
-    step(count?: number): void | Promise<void>;
-    write(bytes: Uint8Array): Promise<void>;
-    text(text: string): Promise<void>;
-}
-/** Linear scan in admitted format bytes; no native formatting or regexp engine. */
-export declare function compileFindFormat(value: ShellValue, budget: FindFormatBudget): Promise<(entry: FindFormatEntry) => Promise<void>>;
+export * from "../../safe-bash-command-find/find-format.js";
 //# sourceMappingURL=find-format.d.ts.map

package/dist/safe-bash/commands/find-format.js

@@ -1,162 +1,2 @@
-import { encodeBytes } from "../byte-encoding.js";
-import {} from "../contracts/index.js";
-import { shellValueBytes } from "../contracts/value.js";
-import { yieldTurn } from "../contracts/yield.js";
-import { output, UsageError } from "./internal.js";
-const controls = { 97: 7, 98: 8, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
-/** Cooperative formatting and bounded output batches across all matched entries. */
-export class FindFormatBudget {
-    context;
-    untilYield = 4096;
-    constructor(context) {
-        this.context = context;
-    }
-    step(count = 1) {
-        this.context.signal.throwIfAborted();
-        this.untilYield -= count;
-        if (this.untilYield > 0)
-            return;
-        this.untilYield = 4096;
-        return yieldTurn(this.context.signal);
-    }
-    async write(bytes) {
-        for (let offset = 0; offset < bytes.length; offset += 4096) {
-            const chunk = bytes.subarray(offset, offset + 4096);
-            {
-                const s = this.step(chunk.length);
-                if (s)
-                    await s;
-            }
-            await output(this.context, chunk);
-        }
-    }
-    async text(text) {
-        // Bound each encoding allocation independently of the full pathname length.
-        for (let offset = 0; offset < text.length;) {
-            let end = Math.min(text.length, offset + 1024);
-            if (end < text.length && text.charCodeAt(end - 1) >= 0xd800 && text.charCodeAt(end - 1) <= 0xdbff)
-                end--;
-            const part = text.slice(offset, end);
-            await this.write(encodeBytes(part));
-            offset = end;
-        }
-    }
-}
-async function field(entry, code, budget) {
-    if (code === "p")
-        return entry.display;
-    if (code === "P")
-        return entry.relative;
-    if (code === "H")
-        return entry.root;
-    if (code === "s")
-        return String(entry.stat.size);
-    if (code === "d")
-        return String(entry.depth);
-    if (code === "y")
-        return ({ file: "f", directory: "d", symlink: "l", character: "c" })[entry.stat.type];
-    let end = entry.display.length;
-    while (end > 1 && entry.display[end - 1] === "/") {
-        {
-            const s = budget.step();
-            if (s)
-                await s;
-        }
-        end--;
-    }
-    let slash = end - 1;
-    while (slash >= 0 && entry.display[slash] !== "/") {
-        {
-            const s = budget.step();
-            if (s)
-                await s;
-        }
-        slash--;
-    }
-    const start = code === "f" ? slash + 1 : 0;
-    const finish = code === "f" ? end : slash === 0 ? 1 : slash;
-    if (code === "f" && end === 1 && entry.display[0] === "/")
-        return "/";
-    if (code === "h" && slash < 0)
-        return ".";
-    // Charge retained substring copying as well as the backwards component scan.
-    for (let offset = start; offset < finish; offset += 4096)
-        await budget.step(Math.min(4096, finish - offset));
-    return entry.display.slice(start, finish);
-}
-/** Linear scan in admitted format bytes; no native formatting or regexp engine. */
-export async function compileFindFormat(value, budget) {
-    const source = shellValueBytes(value);
-    const parts = [];
-    let literal = 0;
-    let index = 0;
-    const flush = () => { if (index > literal)
-        parts.push({ start: literal, end: index }); };
-    while (index < source.length) {
-        {
-            const s = budget.step();
-            if (s)
-                await s;
-        }
-        const byte = source[index];
-        if (byte !== 37 && byte !== 92) {
-            index++;
-            continue;
-        }
-        flush();
-        const next = source[++index];
-        if (byte === 37) {
-            if (next === 37)
-                parts.push({ byte: 37 });
-            else if (next !== undefined && "pfhsdPHy".includes(String.fromCharCode(next)))
-                parts.push({ directive: String.fromCharCode(next) });
-            else
-                throw new UsageError("unsupported printf format directive or modifier");
-            index++;
-        }
-        else {
-            if (next === 99) {
-                literal = source.length;
-                break;
-            }
-            if (next !== undefined && Object.hasOwn(controls, next)) {
-                parts.push({ byte: controls[next] });
-                index++;
-            }
-            else if (next !== undefined && next >= 48 && next <= 55) {
-                let value = 0;
-                const end = Math.min(source.length, index + 3);
-                while (index < end && source[index] >= 48 && source[index] <= 55) {
-                    {
-                        const s = budget.step();
-                        if (s)
-                            await s;
-                    }
-                    value = value * 8 + source[index++] - 48;
-                }
-                parts.push({ byte: value & 255 });
-            }
-            else
-                throw new UsageError("unsupported printf format escape");
-        }
-        literal = index;
-    }
-    if (literal < source.length && index > literal)
-        parts.push({ start: literal, end: index });
-    return async (entry) => {
-        for (const part of parts) {
-            {
-                const s = budget.step();
-                if (s)
-                    await s;
-            }
-            if ("directive" in part)
-                await budget.text(await field(entry, part.directive, budget));
-            else if ("byte" in part)
-                await budget.write(Uint8Array.of(part.byte));
-            else
-                await budget.write(source.subarray(part.start, part.end));
-        }
-    };
-}
+export * from "../../safe-bash-command-find/find-format.js";
 //# sourceMappingURL=find-format.js.map

package/dist/safe-bash/commands/find.d.ts

@@ -1,19 +1,3 @@
-import { type CommandDefinition, type CommandHandler } from "../contracts/index.js";
-export declare function findCommands(execute: CommandHandler, maxDirectoryEntries?: number): CommandDefinition[];
-export interface SyncFindNodeInfo {
-    type: "file" | "directory" | "symlink";
-    size: number;
-    mode: number;
-    ino?: number;
-    nlink?: number;
-    children?: Array<{
-        name: string;
-        type: "file" | "directory" | "symlink";
-        size: number;
-        mode: number;
-        ino?: number;
-        target?: string;
-    }>;
-}
-export declare function evalSyncFind(rawArgs: readonly string[], cwd: string, inspectNode: (path: string, followFinal: boolean) => SyncFindNodeInfo | undefined, allowNullBytes?: boolean): string | undefined;
+export * from "../../safe-bash-command-find/find.js";
+export { createFindDefinitions as findCommands } from "../../safe-bash-command-find/find.js";
 //# sourceMappingURL=find.d.ts.map