zidane-ui/workspace/headless

The tab the panel shows: the focused group's pick, else its first.

base with page after it: its rows join the sections of the same id (a row already shown, by id, is not repeated), its other sections follow, and its more replaces base's. The header (title, controls, search) stays base's. Past PANEL_PAGED_ITEMS rows, the rest is dropped and there is no more.

Whether binding is one of cwd's.

The binding a panel's content belongs to: the folder it loads against, and the session (or none).

The narrowest the chat may get with share set or not.

Remove a tab. A group left empty collapses; when it was focused, the group before it takes the focus.

A new layout memory over options.storage.

Layouts kept in memory for the page's life.

Builds the open decisions over the app's setting, its OS actions and its panel actions.

Creates an empty PanelContents.

Creates an empty PanelFocusStore.

Layouts kept in a Storage under one key, as { version: 1, scopes }. Each read is validated (parseWorkspaceLayout); unreadable or foreign data reads as nothing stored. A write from another tab (the storage event) is read again and notified. A full or missing storage keeps the change in memory.

Creates the panel actions over a layout store.

A dragged tab dropped. On its own strip it is a reorder: nothing else changes (the group keeps showing what it showed). Anywhere else it moves (or splits off) and is shown, focused, where it lands.

The group holding tabId, or null.

The focused group (the first one if the stored id is stale).

Show tabId in its group and focus that group (no-op when the tree lacks it).

The ids of every group under node, in order.

Every group, depth first (top/left to bottom/right).

Every group on screen, top/left to bottom/right.

The project a scope's shared layout lives under: the root, qualified by the server for a server session (the same path on two hosts is two projects).

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

Largest width a column may take while the chat keeps chatMin.

tabId moved delta slots within visible (its group's tabs on screen, in order); hidden tabs keep theirs.

What a panel drag to width saves: past the usual chat floor it becomes a share of the room beside the sidebar, otherwise a plain width.

The mark a panel's tab draws: icon.gui as an icon, else its extension's mark. undefined: a tab with neither (an app's tab without an icon).

One group holding tabs, showing active.

A stored layout, validated field by field; older shapes migrate (the flat tab strip, the bottom group).

A stored panel tree, validated. Older layouts migrate once, on read: a bare group tree (no focus, no counter) and, before groups, the flat strip (panelTabs + panelActiveId), which becomes one group.

A stored tree, validated; null when it is not one.

A stored layout, validated field by field: what cannot be read falls back to fallback's, so stale or foreign data never shows an impossible state.

Pin tabId (into groupId, default the focused group) and show it.

Add tabId to groupId (default: the focused group) unless the tree has it.

New shares for split splitId as shown: shown lists each shown child's group ids (resizeShownSplit).

Fits the sidebar, the chat and the side panel into the window (see the module comment for the order things give).

Whether two attentions show the same. live is part of the value: a flip from counting to "in use" must land.

Whether two layouts hold the same thing (the tree compared by value).

Remembers where to reveal absPath when the Files tab opens it next.

The width a panel opens at when its project never sized it: half the room the sidebar leaves, so the panel and the chat start side by side at 50/50. A plain width, recomputed as the window changes: the chat's floor still squeezes it, then floats it, in a narrow window.

Take tabId out into a new group beside (right) or below (bottom) its own, focused.

The split id as shown, null when it is not on screen.

The position waiting for absPath, removed as it is returned; null when none waits.

Every tab in the tree, group by group.

The tree as shown: only tabs the catalog offers here, groups left empty collapsed, each group's active tab resolved (its pick, else its first). With fillEmpty a strip whose tabs are all hidden here shows the catalog's first tab instead (not stored until the user picks).

The chat's floor once the user has dragged the panel past CHAT_MIN.

The default English strings of the side panel. Override any of them through WorkspaceProvider.

A panel with nothing loaded.

A layout with every default (the side panel on Artifacts, closed).

A layout with nothing stored: closed, no tab.

The storage key the layouts live under.

A floating panel always leaves this much of the chat visible to click on.

Rows kept across every page of one panel, at most: past it, Show more goes away.

The default storage key of createStorageLayouts.

One window's layout memory; see the top of this file.

Options of createLayoutMemory.

The columns' effective widths and modes.

What a layout is attached to: a folder, optionally bound to a session (or to the new-chat draft that will become one). The desktop app's Scope has this shape, so it passes its own.

Options shared by the layout stores.

What resolveLayout fits: the window, and each column's wanted width and floor.

A WorkspaceLayouts kept in memory, plus a way to write as another window would.

The decisions createOpenTarget returns.

What createOpenTarget needs.

A click's modifiers.

JSON-safe content a panel's load returns. The host paints it with its own components.

An extension panel's last content, with its loading and pending flags.

The content cache's store.

The last focus asked for in one scope.

The focus asked per scope.

A group of tabs: one strip, one body showing its active tab.

One group of tabs on screen: its own strip and active tab.

A load context as it arrives from across a boundary (the GUI renderer) or from host UI state, before the host binds it: every field optional. normalizePanelLoadContext reduces untrusted input to this shape; resolvePanelLoadContext turns it into the PanelLoadContext load / onAction receive.

Groups (or splits) side by side or stacked.

A split on screen: its children side by side (row) or stacked (col).

The side panel's layout document: the tab groups, the focused one and the id counter.

How a scope's window was left: the side panel, the Files tab, the terminal drawer, the composer badges.

Options of createStorageLayouts.

A tab has something for the user. attention is the warn-toned, pulsing kind (the agent is waiting on an answer); info is a quiet count (open todos). Kept per scope so a badge earned on one session never shows on another and comes back when switching back.

Where the workspace keeps its layouts and finds extension panels. Leave a member out and what needs it falls back.

One scope's side panel, as stored.

The layouts of every scope, read synchronously so a scope switch shows its layout in the same render.

The panel's layout actions.

Options of createWorkspaceOps.

What the ops read from the latest render: what is on screen.

A panel's content changed in a folder.

Extension-contributed panels: their catalog per folder, their content and their actions.

One extension panel an app offers in a folder.

What a layout belongs to: a session, a folder, a draft. The kit only reads key; an app adds what its host needs to find the record (the desktop app's scope carries the folder whose template a new session copies).

A tab the workspace can show. An app's own kinds are builtin: true and render through its WorkspaceTabRegistry; builtin: false is an extension panel whose content loads from WorkspaceHost.panels. zidane/chat/pure's PanelTab (the desktop app's catalog) is one.

Where a drop lands on a group: into it, or a new group on one of its edges.

A changed layout, or a function of the layout stored right now.

The Storage calls createStorageLayouts makes (localStorage, sessionStorage or a double).

Where a click opens: the editor (the OS) or the side panel.

Every binding's entries, by panel id. Replaced (never mutated) on each change.

A node of the group tree.

What panelTabMark reads of a tab.

A node of the tree as shown.

How a split lays out its children: side by side (row) or stacked (col).

The edge a new group splits off at.

Where a dragged tab is dropped: a strip (before a tab, null: at its end), or a group's body.

Why an extension panel call failed, for the panel to word through its labels.

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

What running a panel action answered.