zidane-ui/files/headless

A layout that lasts as long as the store: for an app that keeps none.

A drop as import items (importEntries, zidane/chat/pure): dropped folders walked through their entries, files read when their turn comes.

What a drop holds, taken now: a DataTransfer's items are gone once the drop event returns, so its files and their entries are read here.

What a refusal says, in the files labels.

The scope's folder for file views: the session's workspace URI when its files are elsewhere, else its cwd.

The scope's identity: the session when bound, else draft:<id> or project:<root>.

Whether a drag carries files from outside the page (the file manager).

name in folder dir.

Whether path is root or inside it.

Every occurrence of query in text, as UTF-16 offsets.

The media a path names, by its extension; null for everything else.

Where path is once from moved to to (itself, or inside a moved folder); null when the move does not touch it.

The last segment of path.

The folder holding path ('': the root).

Stored preferences, validated: unknown or broken fields fall back to the defaults, numbers are clamped. undefined when raw is not a JSON object.

The next index when stepping direction through length items from current (-1: none), wrapping; -1 when there are none.

The paths to act on when several are picked: a path inside another picked folder goes with it, so it is left out.

The preferences before any change.

The default English strings of the Files and Diffs tabs. Override any of them through FilesProvider.

A fresh scope's layout.

The per-tool diagnostics timeout, in seconds.

The key the preferences live under.

The language servers' idle shutdown, in minutes.

One matching line of a search in files.

Options of FilesHost.search.

A search in files.

One finding from a project tool or a language server, positions 1-based like editors show them.

A diagnostics run.

Options of FilesDiagnostics.run.

One thing dropped from outside the page, taken while the drop lasts (a DataTransfer is emptied after it).

The stored preferences: read with get, follow with subscribe, change with set.

The editor preferences.

Rows cut or copied in the tree, waiting for a paste.

The chat a view adds to: the composer receiving the view's scope.

The project's own linters and typecheckers.

Entry actions on a folder's files: what the tree's new file and folder, rename, move, copy, delete and drops from outside run. Paths are relative to the folder, never .. or absolute. Nothing is overwritten: a create, move or rename onto a taken name is refused (exists); a copy or an import takes the next free name (a copy.ts). A refusal resolves; it does not throw.

The files host. Every member is optional.

What next/previous/close/find keys do inside a tab (the app routes them by focus).

What the Files tab keeps per scope.

Where a scope's layout lives: read with get, follow with subscribe, change with update.

Language servers: live findings while typing, hovers, completion and go to definition.

What a view works from: a folder, optionally bound to a session (or the new-chat draft).

What the platform does with a path outside the page.

One path's git status.

The rest of a completion item, fetched when it is selected or accepted.

One completion candidate, ready to insert.

A completion answer; id names it for FilesLsp.resolveCompletion.

A definition target, and the symbol it was asked from when the server says.

A hover answer; busy says why text may be missing (the server is still loading the project).

A position in a file, 1-based.

0-based LSP range.

One incremental document change, LSP shape (0-based positions in the document before the change).

A file the page shows as media, with its MIME type.

Options of createStorageEditorPrefs.

How text matches.

One entry of a folder listing.

A file as read.

A folder's listing: its entries, and whether the host cut it at its cap.

How the editor wraps a selection when a bracket or quote is typed.

The severity of a finding.

lsp = project tools plus language servers (live while typing, hovers).

When project tools run: on open (and after every change on disk) or only after the editor's own saves.

The Storage calls the editor preferences make (localStorage or a double).

Why an entry action was refused: a taken name, a source gone, an invalid name, no access, over the import limits.

What an entry action did: the path it ended at, or why it was refused (message: the backend's own words).

What an import did: the top-level paths it made, and why it stopped when it did.

The shape of the files label dictionary. Some values are functions that build a string.

How a folder's removals end: in the system trash (recoverable), or gone for good.

Why a folder may have changed: a tool result in it, or the repository moving.

The media kinds a browser plays on its own.

A media file's address: as it is now, or one side of a working-tree change.

When an edited file saves: on ⌘S only, or when the editor loses focus too.

What a guarded write did.