@vividcodeai/embeddedcowork-dev 0.0.3-dev-20260507-b76190e8

package/dist/config/location.js

@@ -0,0 +1,57 @@
+import os from "os";
+import path from "path";
+function resolvePath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return path.resolve(inputPath);
+}
+function isYamlPath(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith(".yaml") || lower.endsWith(".yml");
+}
+function isJsonPath(filePath) {
+    return filePath.toLowerCase().endsWith(".json");
+}
+/**
+ * Resolve EmbeddedCowork's config location into a stable base directory + derived file paths.
+ *
+ * Supported inputs:
+ * - Directory: "~/.config/embeddedcowork"
+ * - YAML file: "~/.config/embeddedcowork/config.yaml" (or any *.yml/*.yaml)
+ * - Legacy JSON file: "~/.config/embeddedcowork/config.json"
+ */
+export function resolveConfigLocation(raw) {
+    const trimmed = (raw ?? "").trim();
+    const fallback = "~/.config/embeddedcowork/config.json";
+    const input = trimmed.length > 0 ? trimmed : fallback;
+    const resolvedInput = resolvePath(input);
+    if (isYamlPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: resolvedInput,
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: path.join(baseDir, "config.json"),
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    if (isJsonPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: path.join(baseDir, "config.yaml"),
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: resolvedInput,
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    const baseDir = resolvedInput;
+    return {
+        baseDir,
+        configYamlPath: path.join(baseDir, "config.yaml"),
+        stateYamlPath: path.join(baseDir, "state.yaml"),
+        legacyJsonPath: path.join(baseDir, "config.json"),
+        instancesDir: path.join(baseDir, "instances"),
+    };
+}

package/dist/config/schema.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+const ModelPreferenceSchema = z.object({
+    providerId: z.string(),
+    modelId: z.string(),
+});
+const AgentModelSelectionSchema = z.record(z.string(), ModelPreferenceSchema);
+const AgentModelSelectionsSchema = z.record(z.string(), AgentModelSelectionSchema);
+const PreferencesSchema = z
+    .object({
+    showThinkingBlocks: z.boolean().default(false),
+    thinkingBlocksExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    showTimelineTools: z.boolean().default(true),
+    promptSubmitOnEnter: z.boolean().default(false),
+    lastUsedBinary: z.string().optional(),
+    locale: z.string().optional(),
+    environmentVariables: z.record(z.string()).default({}),
+    modelRecents: z.array(ModelPreferenceSchema).default([]),
+    modelFavorites: z.array(ModelPreferenceSchema).default([]),
+    modelThinkingSelections: z.record(z.string(), z.string()).default({}),
+    diffViewMode: z.enum(["split", "unified"]).default("split"),
+    toolOutputExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    diagnosticsExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    showUsageMetrics: z.boolean().default(true),
+    autoCleanupBlankSessions: z.boolean().default(true),
+    listeningMode: z.enum(["local", "all"]).default("local"),
+    logLevel: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).default("DEBUG"),
+    // OS notifications
+    osNotificationsEnabled: z.boolean().default(false),
+    osNotificationsAllowWhenVisible: z.boolean().default(false),
+    notifyOnNeedsInput: z.boolean().default(true),
+    notifyOnIdle: z.boolean().default(true),
+})
+    // Preserve unknown preference keys so newer configs survive older binaries.
+    .passthrough();
+const RecentFolderSchema = z.object({
+    path: z.string(),
+    lastAccessed: z.number().nonnegative(),
+});
+const OpenCodeBinarySchema = z.object({
+    path: z.string(),
+    version: z.string().optional(),
+    lastUsed: z.number().nonnegative(),
+    label: z.string().optional(),
+});
+const ConfigFileSchema = z
+    .object({
+    preferences: PreferencesSchema.default({}),
+    recentFolders: z.array(RecentFolderSchema).default([]),
+    opencodeBinaries: z.array(OpenCodeBinarySchema).default([]),
+    theme: z.enum(["light", "dark", "system"]).optional(),
+})
+    // Preserve unknown top-level keys so optional future features survive downgrades.
+    .passthrough();
+// On-disk config.yaml only stores stable configuration (not volatile state like recent folders).
+const ConfigYamlSchema = z
+    .object({
+    preferences: PreferencesSchema.default({}),
+    opencodeBinaries: z.array(OpenCodeBinarySchema).default([]),
+    theme: z.enum(["light", "dark", "system"]).optional(),
+})
+    .passthrough();
+// On-disk state.yaml stores server-scoped mutable state (per-server, not per-client).
+const StateFileSchema = z
+    .object({
+    recentFolders: z.array(RecentFolderSchema).default([]),
+})
+    .passthrough();
+const DEFAULT_CONFIG = ConfigFileSchema.parse({});
+const DEFAULT_CONFIG_YAML = ConfigYamlSchema.parse({});
+const DEFAULT_STATE = StateFileSchema.parse({});
+export { ModelPreferenceSchema, AgentModelSelectionSchema, AgentModelSelectionsSchema, PreferencesSchema, RecentFolderSchema, OpenCodeBinarySchema, ConfigFileSchema, ConfigYamlSchema, StateFileSchema, DEFAULT_CONFIG, DEFAULT_CONFIG_YAML, DEFAULT_STATE, };

package/dist/events/bus.js

@@ -0,0 +1,45 @@
+import { EventEmitter } from "events";
+export class EventBus extends EventEmitter {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+    }
+    publish(event) {
+        if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
+            this.logger?.debug({ type: event.type }, "Publishing workspace event");
+            if (this.logger?.isLevelEnabled("trace")) {
+                this.logger.trace({ event }, "Workspace event payload");
+            }
+        }
+        return super.emit(event.type, event);
+    }
+    onEvent(listener) {
+        const handler = (event) => listener(event);
+        this.on("workspace.created", handler);
+        this.on("workspace.started", handler);
+        this.on("workspace.error", handler);
+        this.on("workspace.stopped", handler);
+        this.on("workspace.log", handler);
+        this.on("sidecar.updated", handler);
+        this.on("sidecar.removed", handler);
+        this.on("storage.configChanged", handler);
+        this.on("storage.stateChanged", handler);
+        this.on("instance.dataChanged", handler);
+        this.on("instance.event", handler);
+        this.on("instance.eventStatus", handler);
+        return () => {
+            this.off("workspace.created", handler);
+            this.off("workspace.started", handler);
+            this.off("workspace.error", handler);
+            this.off("workspace.stopped", handler);
+            this.off("workspace.log", handler);
+            this.off("sidecar.updated", handler);
+            this.off("sidecar.removed", handler);
+            this.off("storage.configChanged", handler);
+            this.off("storage.stateChanged", handler);
+            this.off("instance.dataChanged", handler);
+            this.off("instance.event", handler);
+            this.off("instance.eventStatus", handler);
+        };
+    }
+}

package/dist/filesystem/__tests__/search-cache.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { beforeEach, describe, it } from "node:test";
+import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates, WORKSPACE_CANDIDATE_CACHE_TTL_MS, } from "../search-cache";
+describe("workspace search cache", () => {
+    beforeEach(() => {
+        clearWorkspaceSearchCache();
+    });
+    it("expires cached candidates after the TTL", () => {
+        const workspacePath = "/tmp/workspace";
+        const startTime = 1000;
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
+        const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
+        assert.ok(beforeExpiry);
+        assert.equal(beforeExpiry.length, 1);
+        assert.equal(beforeExpiry[0].name, "file-a");
+        const afterExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS + 1);
+        assert.equal(afterExpiry, undefined);
+    });
+    it("replaces cached entries when manually refreshed", () => {
+        const workspacePath = "/tmp/workspace";
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
+        const initial = getWorkspaceCandidates(workspacePath);
+        assert.ok(initial);
+        assert.equal(initial[0].name, "file-a");
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        const refreshed = getWorkspaceCandidates(workspacePath);
+        assert.ok(refreshed);
+        assert.equal(refreshed[0].name, "file-b");
+    });
+});
+function createEntry(name) {
+    return {
+        name,
+        path: name,
+        absolutePath: `/tmp/${name}`,
+        type: "file",
+        size: 1,
+        modifiedAt: new Date().toISOString(),
+    };
+}

package/dist/filesystem/browser.js

@@ -0,0 +1,292 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { WINDOWS_DRIVES_ROOT, } from "../api-types";
+const WINDOWS_DRIVE_LETTERS = Array.from({ length: 26 }, (_, i) => String.fromCharCode(65 + i));
+export class FileSystemBrowser {
+    constructor(options) {
+        this.root = path.resolve(options.rootDir);
+        this.unrestricted = Boolean(options.unrestricted);
+        this.homeDir = os.homedir();
+        this.isWindows = process.platform === "win32";
+    }
+    list(relativePath = ".", options = {}) {
+        if (this.unrestricted) {
+            throw new Error("Relative listing is unavailable when running with unrestricted root");
+        }
+        const includeFiles = options.includeFiles ?? true;
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        return this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+    }
+    browse(targetPath, options = {}) {
+        const includeFiles = options.includeFiles ?? true;
+        if (this.unrestricted) {
+            return this.listUnrestricted(targetPath, includeFiles);
+        }
+        return this.listRestrictedWithMetadata(targetPath, includeFiles);
+    }
+    createFolder(parentPath, folderName) {
+        const name = this.normalizeFolderName(folderName);
+        if (this.unrestricted) {
+            const resolvedParent = this.resolveUnrestrictedPath(parentPath);
+            if (this.isWindows && resolvedParent === WINDOWS_DRIVES_ROOT) {
+                throw new Error("Cannot create folders at drive root");
+            }
+            this.assertDirectoryExists(resolvedParent);
+            const absolutePath = this.resolveAbsoluteChild(resolvedParent, name);
+            fs.mkdirSync(absolutePath);
+            return { path: absolutePath, absolutePath };
+        }
+        const normalizedParent = this.normalizeRelativePath(parentPath);
+        const parentAbsolute = this.toRestrictedAbsolute(normalizedParent);
+        this.assertDirectoryExists(parentAbsolute);
+        const relativePath = this.buildRelativePath(normalizedParent, name);
+        const absolutePath = this.toRestrictedAbsolute(relativePath);
+        fs.mkdirSync(absolutePath);
+        return { path: relativePath, absolutePath };
+    }
+    writeFile(relativePath, contents) {
+        if (this.unrestricted) {
+            throw new Error("writeFile is not available in unrestricted mode");
+        }
+        const resolved = this.toRestrictedAbsolute(relativePath);
+        fs.writeFileSync(resolved, contents, "utf-8");
+    }
+    readFile(relativePath) {
+        if (this.unrestricted) {
+            throw new Error("readFile is not available in unrestricted mode");
+        }
+        const resolved = this.toRestrictedAbsolute(relativePath);
+        return fs.readFileSync(resolved, "utf-8");
+    }
+    listRestrictedWithMetadata(relativePath, includeFiles) {
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        const entries = this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+        const metadata = {
+            scope: "restricted",
+            currentPath: normalizedPath,
+            parentPath: normalizedPath === "." ? undefined : this.getRestrictedParent(normalizedPath),
+            rootPath: this.root,
+            homePath: this.homeDir,
+            displayPath: this.resolveRestrictedAbsolute(normalizedPath),
+            pathKind: "relative",
+        };
+        return { entries, metadata };
+    }
+    listUnrestricted(targetPath, includeFiles) {
+        const resolvedPath = this.resolveUnrestrictedPath(targetPath);
+        if (this.isWindows && resolvedPath === WINDOWS_DRIVES_ROOT) {
+            return this.listWindowsDrives();
+        }
+        const entries = this.readDirectoryEntries(resolvedPath, {
+            includeFiles,
+            formatPath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+        });
+        const parentPath = this.getUnrestrictedParent(resolvedPath);
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: resolvedPath,
+            parentPath,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: resolvedPath,
+            pathKind: "absolute",
+        };
+        return { entries, metadata };
+    }
+    listWindowsDrives() {
+        if (!this.isWindows) {
+            throw new Error("Drive listing is only supported on Windows hosts");
+        }
+        const entries = [];
+        for (const letter of WINDOWS_DRIVE_LETTERS) {
+            const drivePath = `${letter}:\\`;
+            try {
+                if (fs.existsSync(drivePath)) {
+                    entries.push({
+                        name: `${letter}:`,
+                        path: drivePath,
+                        absolutePath: drivePath,
+                        type: "directory",
+                    });
+                }
+            }
+            catch {
+                // Ignore inaccessible drives
+            }
+        }
+        // Provide a generic UNC root entry so users can navigate to network shares manually.
+        entries.push({
+            name: "UNC Network",
+            path: "\\\\",
+            absolutePath: "\\\\",
+            type: "directory",
+        });
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: WINDOWS_DRIVES_ROOT,
+            parentPath: undefined,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: "Drives",
+            pathKind: "drives",
+        };
+        return { entries, metadata };
+    }
+    normalizeFolderName(input) {
+        const name = input.trim();
+        if (!name) {
+            throw new Error("Folder name is required");
+        }
+        if (name === "." || name === "..") {
+            throw new Error("Invalid folder name");
+        }
+        if (name.startsWith("~")) {
+            throw new Error("Invalid folder name");
+        }
+        if (name.includes("/") || name.includes("\\")) {
+            throw new Error("Folder name must not include path separators");
+        }
+        if (name.includes("\u0000")) {
+            throw new Error("Invalid folder name");
+        }
+        return name;
+    }
+    assertDirectoryExists(directory) {
+        if (!fs.existsSync(directory)) {
+            throw new Error(`Directory does not exist: ${directory}`);
+        }
+        const stats = fs.statSync(directory);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${directory}`);
+        }
+    }
+    readDirectoryEntries(directory, options) {
+        const dirents = fs.readdirSync(directory, { withFileTypes: true });
+        const results = [];
+        for (const entry of dirents) {
+            const absoluteEntryPath = path.join(directory, entry.name);
+            let stats;
+            try {
+                // Use fs.statSync (not Dirent.isDirectory) so symlinks to directories
+                // are treated as directories in directory-only listings.
+                stats = fs.statSync(absoluteEntryPath);
+            }
+            catch {
+                // Skip entries we cannot stat (insufficient permissions, etc.)
+                continue;
+            }
+            const isDirectory = stats.isDirectory();
+            if (!options.includeFiles && !isDirectory) {
+                continue;
+            }
+            results.push({
+                name: entry.name,
+                path: options.formatPath(entry.name),
+                absolutePath: options.formatAbsolutePath(entry.name),
+                type: isDirectory ? "directory" : "file",
+                size: isDirectory ? undefined : stats.size,
+                modifiedAt: stats.mtime.toISOString(),
+            });
+        }
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    normalizeRelativePath(input) {
+        if (!input || input === "." || input === "./" || input === "/") {
+            return ".";
+        }
+        let normalized = input.replace(/\\+/g, "/");
+        if (normalized.startsWith("./")) {
+            normalized = normalized.replace(/^\.\/+/, "");
+        }
+        if (normalized.startsWith("/")) {
+            normalized = normalized.replace(/^\/+/g, "");
+        }
+        return normalized === "" ? "." : normalized;
+    }
+    buildRelativePath(parent, child) {
+        if (!parent || parent === ".") {
+            return this.normalizeRelativePath(child);
+        }
+        return this.normalizeRelativePath(`${parent}/${child}`);
+    }
+    resolveRestrictedAbsolute(relativePath) {
+        return this.toRestrictedAbsolute(relativePath);
+    }
+    resolveRestrictedAbsoluteChild(parent, child) {
+        const normalized = this.buildRelativePath(parent, child);
+        return this.toRestrictedAbsolute(normalized);
+    }
+    toRestrictedAbsolute(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        const target = path.resolve(this.root, normalized);
+        const relativeToRoot = path.relative(this.root, target);
+        if (relativeToRoot.startsWith("..") || path.isAbsolute(relativeToRoot) && relativeToRoot !== "") {
+            throw new Error("Access outside of root is not allowed");
+        }
+        return target;
+    }
+    resolveUnrestrictedPath(input) {
+        if (!input || input === "." || input === "./") {
+            return this.homeDir;
+        }
+        if (this.isWindows) {
+            if (input === WINDOWS_DRIVES_ROOT) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            const normalized = path.win32.normalize(input);
+            if (/^[a-zA-Z]:/.test(normalized) || normalized.startsWith("\\\\")) {
+                return normalized;
+            }
+            return path.win32.resolve(this.homeDir, normalized);
+        }
+        if (input.startsWith("/")) {
+            return path.posix.normalize(input);
+        }
+        return path.posix.resolve(this.homeDir, input);
+    }
+    resolveAbsoluteChild(parent, child) {
+        if (this.isWindows) {
+            return path.win32.normalize(path.win32.join(parent, child));
+        }
+        return path.posix.normalize(path.posix.join(parent, child));
+    }
+    getRestrictedParent(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        if (normalized === ".") {
+            return undefined;
+        }
+        const segments = normalized.split("/");
+        segments.pop();
+        return segments.length === 0 ? "." : segments.join("/");
+    }
+    getUnrestrictedParent(currentPath) {
+        if (this.isWindows) {
+            const normalized = path.win32.normalize(currentPath);
+            const parsed = path.win32.parse(normalized);
+            if (normalized === WINDOWS_DRIVES_ROOT) {
+                return undefined;
+            }
+            if (normalized === parsed.root) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            return path.win32.dirname(normalized);
+        }
+        const normalized = path.posix.normalize(currentPath);
+        if (normalized === "/") {
+            return undefined;
+        }
+        return path.posix.dirname(normalized);
+    }
+}

package/dist/filesystem/search-cache.js

@@ -0,0 +1,43 @@
+import path from "path";
+export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30000;
+const workspaceCandidateCache = new Map();
+export function getWorkspaceCandidates(rootDir, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const cached = workspaceCandidateCache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.expiresAt <= now) {
+        workspaceCandidateCache.delete(key);
+        return undefined;
+    }
+    return cloneEntries(cached.candidates);
+}
+export function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const freshCandidates = builder();
+    if (!freshCandidates || freshCandidates.length === 0) {
+        workspaceCandidateCache.delete(key);
+        return [];
+    }
+    const storedCandidates = cloneEntries(freshCandidates);
+    workspaceCandidateCache.set(key, {
+        expiresAt: now + WORKSPACE_CANDIDATE_CACHE_TTL_MS,
+        candidates: storedCandidates,
+    });
+    return cloneEntries(storedCandidates);
+}
+export function clearWorkspaceSearchCache(rootDir) {
+    if (typeof rootDir === "undefined") {
+        workspaceCandidateCache.clear();
+        return;
+    }
+    const key = normalizeKey(rootDir);
+    workspaceCandidateCache.delete(key);
+}
+function cloneEntries(entries) {
+    return entries.map((entry) => ({ ...entry }));
+}
+function normalizeKey(rootDir) {
+    return path.resolve(rootDir);
+}

package/dist/filesystem/search.js

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import fuzzysort from "fuzzysort";
+import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates } from "./search-cache";
+const DEFAULT_LIMIT = 100;
+const MAX_LIMIT = 200;
+const MAX_CANDIDATES = 8000;
+const IGNORED_DIRECTORIES = new Set([".git", ".hg", ".svn", "node_modules", "dist", "build", ".next", ".nuxt", ".turbo", ".cache", "coverage"].map((name) => name.toLowerCase()));
+export function searchWorkspaceFiles(rootDir, query, options = {}) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        throw new Error("Search query is required");
+    }
+    const normalizedRoot = path.resolve(rootDir);
+    const limit = normalizeLimit(options.limit);
+    const typeFilter = options.type ?? "all";
+    const refreshRequested = options.refresh === true;
+    let entries;
+    try {
+        if (!refreshRequested) {
+            entries = getWorkspaceCandidates(normalizedRoot);
+        }
+        if (!entries) {
+            entries = refreshWorkspaceCandidates(normalizedRoot, () => collectCandidates(normalizedRoot));
+        }
+    }
+    catch (error) {
+        clearWorkspaceSearchCache(normalizedRoot);
+        throw error;
+    }
+    if (!entries || entries.length === 0) {
+        clearWorkspaceSearchCache(normalizedRoot);
+        return [];
+    }
+    const candidates = buildCandidateEntries(entries, typeFilter);
+    if (candidates.length === 0) {
+        return [];
+    }
+    const matches = fuzzysort.go(trimmedQuery, candidates, {
+        key: "key",
+        limit,
+    });
+    if (!matches || matches.length === 0) {
+        return [];
+    }
+    return matches.map((match) => match.obj.entry);
+}
+function collectCandidates(rootDir) {
+    const queue = [""];
+    const entries = [];
+    while (queue.length > 0 && entries.length < MAX_CANDIDATES) {
+        const relativeDir = queue.pop() || "";
+        const absoluteDir = relativeDir ? path.join(rootDir, relativeDir) : rootDir;
+        let dirents;
+        try {
+            dirents = fs.readdirSync(absoluteDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirent of dirents) {
+            const entryName = dirent.name;
+            const lowerName = entryName.toLowerCase();
+            const relativePath = relativeDir ? `${relativeDir}/${entryName}` : entryName;
+            const absolutePath = path.join(absoluteDir, entryName);
+            if (dirent.isDirectory() && IGNORED_DIRECTORIES.has(lowerName)) {
+                continue;
+            }
+            let stats;
+            try {
+                stats = fs.statSync(absolutePath);
+            }
+            catch {
+                continue;
+            }
+            const isDirectory = stats.isDirectory();
+            if (isDirectory && !IGNORED_DIRECTORIES.has(lowerName)) {
+                if (entries.length < MAX_CANDIDATES) {
+                    queue.push(relativePath);
+                }
+            }
+            const entryType = isDirectory ? "directory" : "file";
+            const normalizedPath = normalizeRelativeEntryPath(relativePath);
+            const entry = {
+                name: entryName,
+                path: normalizedPath,
+                absolutePath: path.resolve(rootDir, normalizedPath === "." ? "" : normalizedPath),
+                type: entryType,
+                size: entryType === "file" ? stats.size : undefined,
+                modifiedAt: stats.mtime.toISOString(),
+            };
+            entries.push(entry);
+            if (entries.length >= MAX_CANDIDATES) {
+                break;
+            }
+        }
+    }
+    return entries;
+}
+function buildCandidateEntries(entries, filter) {
+    const filtered = [];
+    for (const entry of entries) {
+        if (!shouldInclude(entry.type, filter)) {
+            continue;
+        }
+        filtered.push({ entry, key: buildSearchKey(entry) });
+    }
+    return filtered;
+}
+function normalizeLimit(limit) {
+    if (!limit || Number.isNaN(limit)) {
+        return DEFAULT_LIMIT;
+    }
+    const clamped = Math.min(Math.max(limit, 1), MAX_LIMIT);
+    return clamped;
+}
+function shouldInclude(entryType, filter) {
+    return filter === "all" || entryType === filter;
+}
+function normalizeRelativeEntryPath(relativePath) {
+    if (!relativePath) {
+        return ".";
+    }
+    let normalized = relativePath.replace(/\\+/g, "/");
+    if (normalized.startsWith("./")) {
+        normalized = normalized.replace(/^\.\/+/, "");
+    }
+    if (normalized.startsWith("/")) {
+        normalized = normalized.replace(/^\/+/g, "");
+    }
+    return normalized || ".";
+}
+function buildSearchKey(entry) {
+    return entry.path.toLowerCase();
+}