@selesai/code 0.13.11 → 0.13.13

package/dist/utils/image-convert.js

@@ -1,44 +0,0 @@
-import { applyExifOrientation } from "./exif-orientation.js";
-import { loadPhoton } from "./photon.js";
-export async function convertImageBytesToPng(bytes) {
-    const photon = await loadPhoton();
-    if (!photon) {
-        // Photon not available, can't convert
-        return null;
-    }
-    try {
-        const rawImage = photon.PhotonImage.new_from_byteslice(bytes);
-        const image = applyExifOrientation(photon, rawImage, bytes);
-        if (image !== rawImage)
-            rawImage.free();
-        try {
-            return new Uint8Array(image.get_bytes());
-        }
-        finally {
-            image.free();
-        }
-    }
-    catch {
-        // Conversion failed
-        return null;
-    }
-}
-/**
- * Convert image to PNG format for terminal display.
- * Kitty graphics protocol requires PNG format (f=100).
- */
-export async function convertToPng(base64Data, mimeType) {
-    // Already PNG, no conversion needed
-    if (mimeType === "image/png") {
-        return { data: base64Data, mimeType };
-    }
-    const bytes = new Uint8Array(Buffer.from(base64Data, "base64"));
-    const pngBytes = await convertImageBytesToPng(bytes);
-    if (!pngBytes) {
-        return null;
-    }
-    return {
-        data: Buffer.from(pngBytes).toString("base64"),
-        mimeType: "image/png",
-    };
-}

package/dist/utils/image-process.d.ts

@@ -1,17 +0,0 @@
-import { type ImageResizeOptions } from "./image-resize.ts";
-export interface ProcessImageOptions {
-    /** Whether to resize images to inline provider limits. Default: true */
-    autoResizeImages?: boolean;
-    /** Optional resize overrides. Uses resizeImage defaults when omitted. */
-    resizeOptions?: ImageResizeOptions;
-}
-export type ProcessImageResult = {
-    ok: true;
-    data: string;
-    mimeType: string;
-    hints: string[];
-} | {
-    ok: false;
-    message: string;
-};
-export declare function processImage(bytes: Uint8Array, mimeType: string, options?: ProcessImageOptions): Promise<ProcessImageResult>;

package/dist/utils/image-process.js

@@ -1,82 +0,0 @@
-import { convertImageBytesToPng } from "./image-convert.js";
-import { formatDimensionNote, resizeImage } from "./image-resize.js";
-function baseMimeType(mimeType) {
-    return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
-}
-function normalizeSupportedImageMimeType(mimeType) {
-    switch (baseMimeType(mimeType)) {
-        case "image/png":
-            return "image/png";
-        case "image/jpeg":
-        case "image/jpg":
-            return "image/jpeg";
-        case "image/gif":
-            return "image/gif";
-        case "image/webp":
-            return "image/webp";
-        default:
-            return null;
-    }
-}
-async function normalizeImage(bytes, mimeType) {
-    const normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
-    if (normalizedMimeType) {
-        return { bytes, mimeType: normalizedMimeType };
-    }
-    const pngBytes = await convertImageBytesToPng(bytes);
-    if (!pngBytes) {
-        return null;
-    }
-    return {
-        bytes: pngBytes,
-        mimeType: "image/png",
-        convertedFrom: baseMimeType(mimeType),
-    };
-}
-function conversionHint(from, to) {
-    if (!from || from === to)
-        return undefined;
-    return `[Image converted from ${from} to ${to}.]`;
-}
-export async function processImage(bytes, mimeType, options) {
-    const autoResizeImages = options?.autoResizeImages ?? true;
-    const normalized = await normalizeImage(bytes, mimeType);
-    if (!normalized) {
-        return {
-            ok: false,
-            message: "[Image omitted: could not be converted to a supported inline image format.]",
-        };
-    }
-    if (autoResizeImages) {
-        const resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
-        if (!resized) {
-            return {
-                ok: false,
-                message: "[Image omitted: could not be resized below the inline image size limit.]",
-            };
-        }
-        const hints = [];
-        const convertedHint = conversionHint(normalized.convertedFrom, resized.mimeType);
-        if (convertedHint)
-            hints.push(convertedHint);
-        const dimensionNote = formatDimensionNote(resized);
-        if (dimensionNote)
-            hints.push(dimensionNote);
-        return {
-            ok: true,
-            data: resized.data,
-            mimeType: resized.mimeType,
-            hints,
-        };
-    }
-    const hints = [];
-    const convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
-    if (convertedHint)
-        hints.push(convertedHint);
-    return {
-        ok: true,
-        data: Buffer.from(normalized.bytes).toString("base64"),
-        mimeType: normalized.mimeType,
-        hints,
-    };
-}

package/dist/utils/image-resize-core.d.ts

@@ -1,29 +0,0 @@
-export interface ImageResizeOptions {
-    maxWidth?: number;
-    maxHeight?: number;
-    maxBytes?: number;
-    jpegQuality?: number;
-}
-export interface ResizedImage {
-    data: string;
-    mimeType: string;
-    originalWidth: number;
-    originalHeight: number;
-    width: number;
-    height: number;
-    wasResized: boolean;
-}
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Returns null if the image cannot be resized below maxBytes.
- *
- * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
- * returns null.
- *
- * Strategy for staying under maxBytes:
- * 1. First resize to maxWidth/maxHeight
- * 2. Try both PNG and JPEG formats, pick the smaller one
- * 3. If still too large, try JPEG with decreasing quality
- * 4. If still too large, progressively reduce dimensions until 1x1
- */
-export declare function resizeImageInProcess(inputBytes: Uint8Array, mimeType: string, options?: ImageResizeOptions): Promise<ResizedImage | null>;

package/dist/utils/image-resize-core.js

@@ -1,123 +0,0 @@
-import { applyExifOrientation } from "./exif-orientation.js";
-import { loadPhoton } from "./photon.js";
-// 4.5MB of base64 payload. Provides headroom below Anthropic's 5MB limit.
-const DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
-const DEFAULT_OPTIONS = {
-    maxWidth: 2000,
-    maxHeight: 2000,
-    maxBytes: DEFAULT_MAX_BYTES,
-    jpegQuality: 80,
-};
-function encodeCandidate(buffer, mimeType) {
-    const data = Buffer.from(buffer).toString("base64");
-    return {
-        data,
-        encodedSize: Buffer.byteLength(data, "utf-8"),
-        mimeType,
-    };
-}
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Returns null if the image cannot be resized below maxBytes.
- *
- * Uses Photon (Rust/WASM) for image processing. If Photon is not available,
- * returns null.
- *
- * Strategy for staying under maxBytes:
- * 1. First resize to maxWidth/maxHeight
- * 2. Try both PNG and JPEG formats, pick the smaller one
- * 3. If still too large, try JPEG with decreasing quality
- * 4. If still too large, progressively reduce dimensions until 1x1
- */
-export async function resizeImageInProcess(inputBytes, mimeType, options) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4;
-    const photon = await loadPhoton();
-    if (!photon) {
-        return null;
-    }
-    let image;
-    try {
-        const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
-        image = applyExifOrientation(photon, rawImage, inputBytes);
-        if (image !== rawImage)
-            rawImage.free();
-        const originalWidth = image.get_width();
-        const originalHeight = image.get_height();
-        const format = mimeType.split("/")[1] ?? "png";
-        // Check if already within all limits (dimensions AND encoded size)
-        if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
-            return {
-                data: Buffer.from(inputBytes).toString("base64"),
-                mimeType: mimeType || `image/${format}`,
-                originalWidth,
-                originalHeight,
-                width: originalWidth,
-                height: originalHeight,
-                wasResized: false,
-            };
-        }
-        // Calculate initial dimensions respecting max limits
-        let targetWidth = originalWidth;
-        let targetHeight = originalHeight;
-        if (targetWidth > opts.maxWidth) {
-            targetHeight = Math.round((targetHeight * opts.maxWidth) / targetWidth);
-            targetWidth = opts.maxWidth;
-        }
-        if (targetHeight > opts.maxHeight) {
-            targetWidth = Math.round((targetWidth * opts.maxHeight) / targetHeight);
-            targetHeight = opts.maxHeight;
-        }
-        function tryEncodings(width, height, jpegQualities) {
-            const resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
-            try {
-                const candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
-                for (const quality of jpegQualities) {
-                    candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
-                }
-                return candidates;
-            }
-            finally {
-                resized.free();
-            }
-        }
-        const qualitySteps = Array.from(new Set([opts.jpegQuality, 85, 70, 55, 40]));
-        let currentWidth = targetWidth;
-        let currentHeight = targetHeight;
-        while (true) {
-            const candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
-            for (const candidate of candidates) {
-                if (candidate.encodedSize < opts.maxBytes) {
-                    return {
-                        data: candidate.data,
-                        mimeType: candidate.mimeType,
-                        originalWidth,
-                        originalHeight,
-                        width: currentWidth,
-                        height: currentHeight,
-                        wasResized: true,
-                    };
-                }
-            }
-            if (currentWidth === 1 && currentHeight === 1) {
-                break;
-            }
-            const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
-            const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
-            if (nextWidth === currentWidth && nextHeight === currentHeight) {
-                break;
-            }
-            currentWidth = nextWidth;
-            currentHeight = nextHeight;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (image) {
-            image.free();
-        }
-    }
-}

package/dist/utils/image-resize-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/image-resize-worker.js

@@ -1,30 +0,0 @@
-import { parentPort } from "node:worker_threads";
-import { resizeImageInProcess } from "./image-resize-core.js";
-function isResizeImageWorkerRequest(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const record = value;
-    return record.inputBytes instanceof Uint8Array && typeof record.mimeType === "string";
-}
-const port = parentPort;
-if (!port) {
-    throw new Error("image resize worker requires parentPort");
-}
-port.once("message", (message) => {
-    void (async () => {
-        try {
-            if (!isResizeImageWorkerRequest(message)) {
-                throw new Error("Invalid image resize worker request");
-            }
-            const result = await resizeImageInProcess(message.inputBytes, message.mimeType, message.options);
-            const response = { result };
-            port.postMessage(response);
-        }
-        catch (error) {
-            const response = {
-                error: error instanceof Error ? error.message : String(error),
-            };
-            port.postMessage(response);
-        }
-    })();
-});

package/dist/utils/image-resize.d.ts

@@ -1,15 +0,0 @@
-import { type ImageResizeOptions, type ResizedImage } from "./image-resize-core.ts";
-export type { ImageResizeOptions, ResizedImage } from "./image-resize-core.ts";
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Runs Photon in a worker thread so WASM decoding, resizing, and encoding do not
- * block the TUI event loop. If the worker cannot be loaded (for example in some
- * Bun compiled executable layouts), fall back to in-process resizing so image
- * reads still work.
- */
-export declare function resizeImage(inputBytes: Uint8Array, mimeType: string, options?: ImageResizeOptions): Promise<ResizedImage | null>;
-/**
- * Format a dimension note for resized images.
- * This helps the model understand the coordinate mapping.
- */
-export declare function formatDimensionNote(result: ResizedImage): string | undefined;

package/dist/utils/image-resize.js

@@ -1,96 +0,0 @@
-import { Worker } from "node:worker_threads";
-import { resizeImageInProcess } from "./image-resize-core.js";
-function toTransferableBytes(input) {
-    // Transfer detaches the buffer, so transfer a worker-owned copy and leave the
-    // caller's bytes intact.
-    return new Uint8Array(input);
-}
-function isResizeImageWorkerResponse(value) {
-    return value !== null && typeof value === "object";
-}
-function createResizeWorker(workerSpecifier) {
-    return new Worker(workerSpecifier);
-}
-async function resizeImageInWorker(workerSpecifier, inputBytes, mimeType, options) {
-    const worker = createResizeWorker(workerSpecifier);
-    try {
-        const inputBytesForWorker = toTransferableBytes(inputBytes);
-        return await new Promise((resolve, reject) => {
-            let settled = false;
-            const settle = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                resolve(result);
-            };
-            const fail = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                reject(error);
-            };
-            worker.once("message", (message) => {
-                if (!isResizeImageWorkerResponse(message)) {
-                    fail(new Error("Invalid image resize worker response"));
-                    return;
-                }
-                if (message.error) {
-                    fail(new Error(message.error));
-                    return;
-                }
-                settle(message.result ?? null);
-            });
-            worker.once("error", fail);
-            worker.once("exit", (code) => {
-                if (!settled) {
-                    fail(new Error(`Image resize worker exited with code ${code}`));
-                }
-            });
-            worker.postMessage({
-                inputBytes: inputBytesForWorker,
-                mimeType,
-                options,
-            }, [inputBytesForWorker.buffer]);
-        });
-    }
-    finally {
-        void worker.terminate().catch(() => undefined);
-    }
-}
-/**
- * Resize an image to fit within the specified max dimensions and encoded file size.
- * Runs Photon in a worker thread so WASM decoding, resizing, and encoding do not
- * block the TUI event loop. If the worker cannot be loaded (for example in some
- * Bun compiled executable layouts), fall back to in-process resizing so image
- * reads still work.
- */
-export async function resizeImage(inputBytes, mimeType, options) {
-    const isTypeScriptRuntime = import.meta.url.endsWith(".ts");
-    const workerUrl = new URL(isTypeScriptRuntime ? "./image-resize-worker.ts" : "./image-resize-worker.js", import.meta.url);
-    // Bun compiled executables resolve worker entrypoints by string path, not via
-    // new URL(..., import.meta.url). Try the string path first under Bun so the
-    // release binary uses the embedded worker instead of falling back in-process.
-    if (typeof process.versions.bun === "string") {
-        try {
-            return await resizeImageInWorker("./src/utils/image-resize-worker.ts", inputBytes, mimeType, options);
-        }
-        catch { }
-    }
-    try {
-        return await resizeImageInWorker(workerUrl, inputBytes, mimeType, options);
-    }
-    catch {
-        return resizeImageInProcess(inputBytes, mimeType, options);
-    }
-}
-/**
- * Format a dimension note for resized images.
- * This helps the model understand the coordinate mapping.
- */
-export function formatDimensionNote(result) {
-    if (!result.wasResized) {
-        return undefined;
-    }
-    const scale = result.originalWidth / result.width;
-    return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
-}

package/dist/utils/json.d.ts

@@ -1,2 +0,0 @@
-/** Strip `//` line comments and trailing commas from JSON, leaving string literals untouched. */
-export declare function stripJsonComments(input: string): string;

package/dist/utils/json.js

@@ -1,6 +0,0 @@
-/** Strip `//` line comments and trailing commas from JSON, leaving string literals untouched. */
-export function stripJsonComments(input) {
-    return input
-        .replace(/"(?:\\.|[^"\\])*"|\/\/[^\n]*/g, (m) => (m[0] === '"' ? m : ""))
-        .replace(/"(?:\\.|[^"\\])*"|,(\s*[}\]])/g, (m, tail) => tail ?? (m[0] === '"' ? m : ""));
-}

package/dist/utils/mime.d.ts

@@ -1,2 +0,0 @@
-export declare function detectSupportedImageMimeType(buffer: Uint8Array): string | null;
-export declare function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null>;

package/dist/utils/mime.js

@@ -1,132 +0,0 @@
-import { open } from "node:fs/promises";
-const IMAGE_TYPE_SNIFF_BYTES = 4100;
-const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
-export function detectSupportedImageMimeType(buffer) {
-    if (startsWith(buffer, [0xff, 0xd8, 0xff])) {
-        return buffer[3] === 0xf7 ? null : "image/jpeg";
-    }
-    if (startsWith(buffer, PNG_SIGNATURE)) {
-        return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null;
-    }
-    if (startsWithAscii(buffer, 0, "GIF")) {
-        return "image/gif";
-    }
-    if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
-        return "image/webp";
-    }
-    if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
-        return "image/bmp";
-    }
-    return null;
-}
-const IMAGE_EXTENSION_MIME_TYPES = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    bmp: "image/bmp",
-    tiff: "image/tiff",
-    tif: "image/tiff",
-    ico: "image/x-icon",
-    heic: "image/heic",
-    heif: "image/heif",
-    avif: "image/avif",
-};
-export async function detectSupportedImageMimeTypeFromFile(filePath) {
-    const fileHandle = await open(filePath, "r");
-    try {
-        const buffer = Buffer.alloc(IMAGE_TYPE_SNIFF_BYTES);
-        const { bytesRead } = await fileHandle.read(buffer, 0, IMAGE_TYPE_SNIFF_BYTES, 0);
-        const detected = detectSupportedImageMimeType(buffer.subarray(0, bytesRead));
-        if (detected)
-            return detected;
-        // ponytail: magic-byte sniffer rejects APNG/JPEG2000 and ignores BMP/TIFF/etc.
-        // Fall back to the file extension so image files are routed to the image path
-        // (resize will no-op to an "omitted" note) instead of being read as text and
-        // flooding the prompt with base64 garbage. SVG is intentionally excluded: it is
-        // text and is correctly handled by the text branch.
-        const ext = filePath.toLowerCase().split(".").pop();
-        return ext ? (IMAGE_EXTENSION_MIME_TYPES[ext] ?? null) : null;
-    }
-    finally {
-        await fileHandle.close();
-    }
-}
-function isPng(buffer) {
-    return (buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR"));
-}
-function isAnimatedPng(buffer) {
-    let offset = PNG_SIGNATURE.length;
-    while (offset + 8 <= buffer.length) {
-        const chunkLength = readUint32BE(buffer, offset);
-        const chunkTypeOffset = offset + 4;
-        if (startsWithAscii(buffer, chunkTypeOffset, "acTL"))
-            return true;
-        if (startsWithAscii(buffer, chunkTypeOffset, "IDAT"))
-            return false;
-        const nextOffset = offset + 8 + chunkLength + 4;
-        if (nextOffset <= offset || nextOffset > buffer.length)
-            return false;
-        offset = nextOffset;
-    }
-    return false;
-}
-function isBmp(buffer) {
-    if (buffer.length < 26)
-        return false;
-    const declaredFileSize = readUint32LE(buffer, 2);
-    const pixelDataOffset = readUint32LE(buffer, 10);
-    const dibHeaderSize = readUint32LE(buffer, 14);
-    if (declaredFileSize !== 0 && declaredFileSize < 26)
-        return false;
-    if (pixelDataOffset < 14 + dibHeaderSize)
-        return false;
-    if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
-        return false;
-    let colorPlanes;
-    let bitsPerPixel;
-    if (dibHeaderSize === 12) {
-        colorPlanes = readUint16LE(buffer, 22);
-        bitsPerPixel = readUint16LE(buffer, 24);
-    }
-    else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
-        if (buffer.length < 30)
-            return false;
-        colorPlanes = readUint16LE(buffer, 26);
-        bitsPerPixel = readUint16LE(buffer, 28);
-    }
-    else {
-        return false;
-    }
-    return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
-}
-function readUint16LE(buffer, offset) {
-    return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
-}
-function readUint32BE(buffer, offset) {
-    return ((buffer[offset] ?? 0) * 0x1000000 +
-        ((buffer[offset + 1] ?? 0) << 16) +
-        ((buffer[offset + 2] ?? 0) << 8) +
-        (buffer[offset + 3] ?? 0));
-}
-function readUint32LE(buffer, offset) {
-    return ((buffer[offset] ?? 0) +
-        ((buffer[offset + 1] ?? 0) << 8) +
-        ((buffer[offset + 2] ?? 0) << 16) +
-        (buffer[offset + 3] ?? 0) * 0x1000000);
-}
-function startsWith(buffer, bytes) {
-    if (buffer.length < bytes.length)
-        return false;
-    return bytes.every((byte, index) => buffer[index] === byte);
-}
-function startsWithAscii(buffer, offset, text) {
-    if (buffer.length < offset + text.length)
-        return false;
-    for (let index = 0; index < text.length; index++) {
-        if (buffer[offset + index] !== text.charCodeAt(index))
-            return false;
-    }
-    return true;
-}

package/dist/utils/open-browser.d.ts

@@ -1,8 +0,0 @@
-/**
- * Open a URL or file in the platform browser/default handler.
- *
- * This intentionally never invokes a shell. On Windows, do not use
- * `cmd /c start`: cmd.exe re-parses metacharacters (&, |, ^, ...) before
- * `start` runs, which would make attacker-controlled URLs injectable.
- */
-export declare function openBrowser(target: string): void;

package/dist/utils/open-browser.js

@@ -1,21 +0,0 @@
-import { spawn } from "node:child_process";
-/**
- * Open a URL or file in the platform browser/default handler.
- *
- * This intentionally never invokes a shell. On Windows, do not use
- * `cmd /c start`: cmd.exe re-parses metacharacters (&, |, ^, ...) before
- * `start` runs, which would make attacker-controlled URLs injectable.
- */
-export function openBrowser(target) {
-    const [cmd, args] = process.platform === "darwin"
-        ? ["open", [target]]
-        : process.platform === "win32"
-            ? ["rundll32", ["url.dll,FileProtocolHandler", target]]
-            : ["xdg-open", [target]];
-    // spawn reports launcher failures (for example, missing xdg-open) via an
-    // error event. Browser launch is best-effort: callers still present the target
-    // to the user, so keep the launcher failure from becoming a process crash.
-    spawn(cmd, args, { stdio: "ignore", detached: true })
-        .on("error", () => { })
-        .unref();
-}

package/dist/utils/paths.d.ts

@@ -1,30 +0,0 @@
-export interface PathInputOptions {
-    /** Trim leading/trailing whitespace before normalization. */
-    trim?: boolean;
-    /** Expand leading `~` to a home directory. Defaults to true. */
-    expandTilde?: boolean;
-    /** Home directory used for `~` expansion. Defaults to `os.homedir()`. */
-    homeDir?: string;
-    /** Strip a leading `@`, used for CLI @file paths. */
-    stripAtPrefix?: boolean;
-    /** Normalize unicode space variants to regular spaces. */
-    normalizeUnicodeSpaces?: boolean;
-}
-/**
- * Resolve a path to its canonical (real) form, following symlinks.
- * Falls back to the raw path if resolution fails (e.g. the target does
- * not exist yet), so that callers never crash on missing filesystem
- * entries.
- */
-export declare function canonicalizePath(path: string): string;
-/**
- * Returns true if the value is NOT a package source (npm:, git:, etc.)
- * or a remote URL protocol. Bare names, relative paths, and file: URLs
- * are considered local.
- */
-export declare function isLocalPath(value: string): boolean;
-export declare function normalizePath(input: string, options?: PathInputOptions): string;
-export declare function resolvePath(input: string, baseDir?: string, options?: PathInputOptions): string;
-export declare function getCwdRelativePath(filePath: string, cwd: string): string | undefined;
-export declare function formatPathRelativeToCwdOrAbsolute(filePath: string, cwd: string): string;
-export declare function markPathIgnoredByCloudSync(path: string): void;