@prettier-ai/dsh-client-ui-workspace 0.1.2-alpha.1

package/lib/index.js

@@ -0,0 +1,11 @@
+//#region lib/types/index.js
+/**
+* Workspace picker plugin, node half. Pure UI plugin: the empty apply exists
+* so the plugin appears in the host cordis.yml / Loader (load and lifecycle
+* follow the host; the browser half ships via exports["./client"], discovered
+* through the package.json dsh.client declaration).
+*/
+/** Host plugin body — no host-side behavior for the workspace picker plugin. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@prettier-ai/dsh-client-ui-workspace`.
+* @module @prettier-ai/dsh-client-ui-workspace/invariant
+*/
+const PACKAGE_NAME = "@prettier-ai/dsh-client-ui-workspace";
+/** Cordis companion plugin name. */
+const name = "client-ui-workspace-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: a pure-consumer plugin registering presentational
+* components into two host-declared slots plus its locale dictionaries — its
+* inject face is stateless RPC wrappers plus a create-and-open call; it
+* emits no cordis events and owns no cross-plugin mutable state.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/WorkspacePicker.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Workspace pick/add flow. WorkspacePickFlow is the reusable core (menu +
+ * path error dialog) consumed directly by WorkspaceBrowser (same package) and
+ * wrapped by WorkspacePicker for the conversation empty-state slot
+ * registration. Directory picking itself lives in the composed flow package's
+ * slot occupant (see the contract module doc): this core only opens the flow,
+ * adopts the picked path, and owns the error surface. Adding a workspace has
+ * exactly one route — pick a host directory, new or existing — because the
+ * occupant's own create-folder affordance already covers creating one.
+ */
+import type { ReactNode, RefObject } from 'react';
+import type { WorkspaceId, WorkspaceSnapshot, WorkspaceView } from '@prettier-ai/dsh-api-workspace-controller/client';
+import type { SnapshotSelectorHook } from '@prettier-ai/dsh-client-ui-slots';
+import type { DirectoryFlowOwnerProps, WorkspacePickerProps } from './contract/slots.ts';
+/** Core flow props: the owner supplies popover control and pick semantics. */
+export interface WorkspacePickFlowProps {
+    /** The standard locale seat, forwarded by whichever slot entry hosts the flow. */
+    t: WorkspacePickerProps['t'];
+    /** Popover visibility (anchor button toggle state, owner-local). */
+    open: boolean;
+    /** The anchor button element — the popover's placement anchor. */
+    anchorRef?: RefObject<HTMLElement | null> | undefined;
+    /** Selector hook over the workspace list (framework standard hook). */
+    useWorkspaces: <S>(selector: (state: WorkspaceSnapshot) => S) => S;
+    /** Adopt a picked host directory as a real Workspace. */
+    createWorkspace: (input: {
+        path: string;
+    }) => Promise<WorkspaceView>;
+    /** Bound occupancy selector hook for this surface's directory-flow hole (empty leaves the surface with no add action). */
+    useDirectoryFlow: SnapshotSelectorHook<boolean>;
+    /** Render this surface's directory-flow hole with the owner conversation (the entry's narrowed renderSlot). */
+    renderDirectoryFlow: (owner: DirectoryFlowOwnerProps) => ReactNode;
+    /** A real Workspace was picked or created. */
+    onPick: (workspaceId: WorkspaceId) => void;
+    /** Close the popover (outside click / Escape / post-pick). */
+    onClose: () => void;
+    /** Only offer the add action, hide existing workspaces. */
+    addOnly?: boolean;
+    /** Menu opening direction relative to the anchor. */
+    side?: 'bottom' | 'top' | 'right';
+    /** Currently active workspace (trailing check in the picker list). */
+    selectedId?: WorkspaceId | undefined;
+}
+/**
+ * Render the pick menu plus the adoption error dialog.
+ * @param props - owner-controlled flow props.
+ * @returns menu + dialog elements.
+ */
+export declare function WorkspacePickFlow({ t, open, anchorRef, useWorkspaces, createWorkspace, useDirectoryFlow, renderDirectoryFlow, onPick, onClose, addOnly, side, selectedId, }: WorkspacePickFlowProps): import("react").JSX.Element;
+/**
+ * The conversation empty-state registration: adapts the owner share to the
+ * core flow (all state and semantics live in the flow / the owner).
+ * @param props - empty-state slot props (owner share + injected creation callback).
+ * @returns the flow element.
+ */
+export declare function WorkspacePicker({ open, anchorRef, useWorkspaces, selectedId, onPick, onClose, createWorkspace, useDirectoryFlow, renderSlot, t, }: WorkspacePickerProps): import("react").JSX.Element;
+//# sourceMappingURL=WorkspacePicker.d.ts.map

package/lib/types/client/contract/slots.d.ts

@@ -0,0 +1,158 @@
+/**
+ * ui-workspace contracts. Two registrations share this package:
+ *
+ * - WorkspaceBrowser fills the sidebar shell's `sidebar.workspaces` hole —
+ *   the whole browsing region (section header, search, grouped/flat session
+ *   list, workspace dialogs). It registers this package's viewing store and
+ *   consumes the shell's two-fact owner share (wide / expandSidebar).
+ * - WorkspacePicker fills the conversation empty-state hole (menu + error
+ *   dialog shared with the browser).
+ *
+ * Each registration also declares one **directory-flow hole** (`single`
+ * kind): the slot a composed picker package's client half fills with its
+ * picking interaction — a renderless native-chooser driver or an in-app
+ * browsing dialog. ui-workspace owns the trigger (the "Add workspace…"
+ * entry, present only while the hole is occupied) and the adoption
+ * semantics (`createWorkspace({ path })`, the retryable error dialog,
+ * Choose again); the occupant owns everything between `open` and the picked path,
+ * including creating a new directory to hand back. That occupant-owned
+ * creation is why adding a workspace has a single route: an unoccupied hole
+ * leaves the surface with no add affordance at all.
+ * Two holes exist because the two menu surfaces are independent slot entries
+ * and a hole has exactly one declaring entry — they carry the same owner
+ * contract and the same occupant.
+ */
+import type { ConnectionGenerationState } from '@prettier-ai/dsh-client-connection/client';
+import type { HostObservable, PropsHooks, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@prettier-ai/dsh-client-ui-slots';
+import type { SessionSearchResultItem } from '@prettier-ai/dsh-api-session-controller/client';
+import type { WorkspaceId, WorkspaceView } from '@prettier-ai/dsh-api-workspace-controller/client';
+import type { SessionId } from '@prettier-ai/dsh-session/types';
+import type { createWorkspaceViewStore } from '../stores.ts';
+/**
+ * Owner share of the directory-flow holes: the complete conversation between
+ * the trigger surface and the picking interaction. The occupant reads `open`
+ * to run/render its interaction and reports exactly one outcome per open.
+ */
+export interface DirectoryFlowOwnerProps {
+    /** True while a picking interaction is requested; flipping back to false withdraws the request. */
+    open: boolean;
+    /** True while the owner adopts a picked path (`createWorkspace` in flight); occupants disable their commit affordances. */
+    busy: boolean;
+    /** The operator picked a directory (absolute host path); the owner adopts it. */
+    onPicked: (path: string) => void;
+    /** The operator dismissed the interaction; the owner just closes the flow. */
+    onCancel: () => void;
+    /** The interaction itself failed (chooser missing, listing denied); the owner shows its error surface. */
+    onError: (message: string) => void;
+}
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        /** Directory-flow hole under the conversation empty-state picker (declared by the WorkspacePicker entry). */
+        'conversation.hero.workspace.directoryFlow': {
+            kind: 'single';
+            scope: 'root';
+            owner: DirectoryFlowOwnerProps;
+        };
+        /** Directory-flow hole under the sidebar browsing region (declared by the WorkspaceBrowser entry). */
+        'sidebar.workspaces.directoryFlow': {
+            kind: 'single';
+            scope: 'root';
+            owner: DirectoryFlowOwnerProps;
+        };
+    }
+}
+/** The two directory-flow holes; a flow package's client half registers its one component into both. */
+export type DirectoryFlowSlotName = 'conversation.hero.workspace.directoryFlow' | 'sidebar.workspaces.directoryFlow';
+/**
+ * Directory-picking share both trigger surfaces consume. Occupancy rides the
+ * inject face's reserved `hooks` compartment: the renderer binds the source
+ * into the `useDirectoryFlow` selector hook, so an empty hole hides the
+ * "Add workspace…" entry reactively and the surface withdraws an open
+ * flow whose occupant unloaded mid-interaction (nobody is left to cancel).
+ */
+export type DirectoryPickingInjected = {
+    hooks: {
+        /** True while this surface's directory-flow hole is occupied. */
+        directoryFlow: HostObservable<boolean>;
+    };
+};
+/** Component-side view of the picking share: the bound occupancy selector hook. */
+export type DirectoryPickingHooks = PropsHooks<DirectoryPickingInjected['hooks']>;
+/**
+ * Browser-private injected share (arrives via the register inject factory).
+ * Data reads use the global framework hooks; these are the Host actions the
+ * browsing region drives.
+ */
+export type WorkspaceBrowserInjected = {
+    hooks: DirectoryPickingInjected['hooks'] & {
+        /** Current generation's Host description, bound by the slot renderer. */
+        connectionGeneration: ConnectionGenerationState;
+    };
+    /**
+     * Start a New Session in a Workspace: reuse-or-create its blank session and
+     * open it; without an explicit workspace, inherit the current Session
+     * Workspace, then the recent Workspace, or clear into the New Session view.
+     */
+    startSession: (workspaceId?: WorkspaceId) => void;
+    /** Open a real Session. */
+    open: (sessionId: SessionId) => void;
+    /**
+     * Search current visible conversation messages. The Host fixes the result
+     * bound; `hasMore` means the query needs narrowing.
+     */
+    searchSessions: (query: string, signal: AbortSignal) => Promise<{
+        items: readonly SessionSearchResultItem[];
+        hasMore: boolean;
+    }>;
+    /** Maximum number of merged rows rendered for one search. */
+    searchResultLimit: number;
+    /** Rename a Session (explicit user title; resolves on host acceptance). */
+    renameSession: (sessionId: SessionId, title: string) => Promise<void>;
+    /** Fork a Session at its last completed turn and open the child. */
+    forkSession: (sessionId: SessionId) => void;
+    /** Rename a Host Workspace (rejects on name conflict; resolves on durability). */
+    renameWorkspace: (workspaceId: WorkspaceId, title: string) => Promise<void>;
+    /** Delete only a Host Workspace registration; directory and Session logs remain. */
+    deleteWorkspace: (workspaceId: WorkspaceId) => Promise<void>;
+    /**
+     * Reorder a Workspace in the durable registry display order.
+     * Omitted anchor appends to the end.
+     */
+    insertWorkspaceBefore: (workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId) => Promise<void>;
+    /**
+     * Archive a Session into the registry-global set: hidden from grouping
+     * surfaces, log and accounting slot retained. Archiving the current
+     * session clears the selection into the New Session view state.
+     */
+    archiveSession: (sessionId: SessionId) => Promise<void>;
+    /**
+     * Reorder a session inside its Workspace account (DOM-insertBefore
+     * semantics: omitted anchor appends to the end). The view refreshes from
+     * the Host response/changed frame; failures leave the order unchanged.
+     */
+    insertSessionBefore: (workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId) => Promise<void>;
+    /** Adopt a picked host directory as a real Workspace before targeting a Session. */
+    createWorkspace: (input: {
+        path: string;
+    }) => Promise<WorkspaceView>;
+};
+/** Full browser props: shell owner share + viewing store + injected actions + the locale seat. */
+export type WorkspaceBrowserProps = PropsRuntime<'sidebar.workspaces'> & PropsRenderSlots<'sidebar.workspaces.directoryFlow'> & PropsStore<ReturnType<typeof createWorkspaceViewStore>> & Omit<WorkspaceBrowserInjected, 'hooks'> & PropsHooks<WorkspaceBrowserInjected['hooks']> & PropsLocale<'workspace'>;
+/**
+ * Picker-private injected share. Pick semantics remain in the owner's onPick
+ * callback; this callback creates only the real Host Workspace. A type alias
+ * supplies the implicit index signature required by the registry.
+ */
+export type WorkspacePickerInjected = DirectoryPickingInjected & {
+    /** Adopt a picked host directory as a real Workspace before targeting a Session. */
+    createWorkspace: (input: {
+        path: string;
+    }) => Promise<WorkspaceView>;
+};
+/**
+ * Full picker props: the owner share plus the creation callback and the
+ * locale seat. The two picker holes (blank-session hero / New-Session view)
+ * share one owner currency, so one composed type serves both registrations.
+ */
+export type WorkspacePickerProps = PropsRuntime<'conversation.hero.workspace'> & PropsRenderSlots<'conversation.hero.workspace.directoryFlow'> & Omit<WorkspacePickerInjected, 'hooks'> & DirectoryPickingHooks & PropsLocale<'workspace'>;
+//# sourceMappingURL=slots.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Workspace plugin, browser half. Two registrations: WorkspaceBrowser fills
+ * the sidebar shell's `sidebar.workspaces` hole (the whole browsing region),
+ * and WorkspacePicker fills the conversation hero's picker hole
+ * (`conversation.hero.workspace` — both hero forms). Both read real Host
+ * Workspaces through the global useWorkspaces hook, and each declares its
+ * own `single` directory-flow child hole for the composed picker package's
+ * client half (see the contract module doc). Export discipline:
+ * packages/client/AGENTS.md.
+ */
+import type { Context } from '@prettier-ai/cordis';
+import type { WorkspaceSnapshot } from '@prettier-ai/dsh-api-workspace-controller/client';
+import type { SnapshotSelectorHook } from '@prettier-ai/dsh-client-ui-slots';
+import { type WorkspaceKey } from './locales.ts';
+export type { UiWorkspace } from './navigation.ts';
+export type { DirectoryFlowOwnerProps, DirectoryFlowSlotName, DirectoryPickingHooks, DirectoryPickingInjected, WorkspaceBrowserInjected, WorkspaceBrowserProps, WorkspacePickerInjected, WorkspacePickerProps, } from './contract/slots.ts';
+export type { WorkspaceKey } from './locales.ts';
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface GlobalStandardProps {
+        /** Selector hook over the pure Workspace Controller snapshot. */
+        useWorkspaces: SnapshotSelectorHook<WorkspaceSnapshot>;
+    }
+    interface LocaleNamespaceMap {
+        /** The workspace browsing region and pick/create flow copy. */
+        workspace: WorkspaceKey;
+    }
+}
+/**
+ * Required services (cordis fiber inject). The target slots are declared by
+ * the ui-sidebar / ui-conversation applies, whose activation order relative
+ * to this one is NOT constrained: dsh.client.inject edges are informational
+ * (loading/prefetch metadata, never apply sequencing) and neither owner
+ * provides a waitable service. apply therefore depends on each slot
+ * declaration through `slots.inject()` instead of assuming order.
+ */
+export declare const inject: string[];
+/**
+ * Register the browser and picker once their slot declarations are on the
+ * ledger. Inject factories return plain callbacks; data reads use the
+ * framework's global hooks.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,138 @@
+/**
+ * `workspace` namespace dictionaries: the browsing region (section header,
+ * search, tree rows, dialogs) and the pick/add flow. Runtime failure
+ * messages (wire error strings) pass through untranslated by policy.
+ */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'group.ungrouped': string;
+    'session.new': string;
+    'section.workspaces': string;
+    'section.sessions': string;
+    'viewOptions.label': string;
+    'groupBy.label': string;
+    'groupBy.workspace': string;
+    'groupBy.flat': string;
+    'orderBy.label': string;
+    'orderBy.manual': string;
+    'orderBy.updated': string;
+    'sessions.expand': string;
+    'sessions.collapse': string;
+    'empty.none': string;
+    'empty.noMatches': string;
+    'workspace.add': string;
+    'search.sessions.aria': string;
+    'search.placeholder': string;
+    'search.clear': string;
+    'search.results.aria': string;
+    'search.pending': string;
+    'search.unavailable': string;
+    'search.noMatches': string;
+    'search.hasMore': string;
+    'menu.addWorkspace': string;
+    'picker.loading': string;
+    'conflict.named': string;
+    'folderError.title': string;
+    'folderError.retry': string;
+    rename: string;
+    'rename.workspace.title': string;
+    'rename.session.title': string;
+    'field.workspaceName': string;
+    'field.sessionName': string;
+    'delete.workspace': string;
+    'delete.desc': string;
+    'delete.pending': string;
+    'menu.fork': string;
+    'menu.archiveSession': string;
+    'sessions.count.one': string;
+    'sessions.count.other': string;
+    'actions.workspace.aria': string;
+    'actions.session.aria': string;
+    'actions.newSession.aria': string;
+    'status.running': string;
+    'status.subagentsRunning.one': string;
+    'status.subagentsRunning.other': string;
+    'status.idle': string;
+    'status.waitingApproval': string;
+    'status.planReview': string;
+    'status.waitingAnswer': string;
+    'status.completed': string;
+    'hover.created': string;
+    'hover.copied': string;
+    'date.ymd': string;
+    'time.now': string;
+    'time.minutes': string;
+    'time.hours': string;
+    'time.days': string;
+    'time.months': string;
+    'time.years': string;
+    'time.ago': string;
+};
+/** The workspace namespace key union. */
+export type WorkspaceKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'group.ungrouped': string;
+    'session.new': string;
+    'section.workspaces': string;
+    'section.sessions': string;
+    'viewOptions.label': string;
+    'groupBy.label': string;
+    'groupBy.workspace': string;
+    'groupBy.flat': string;
+    'orderBy.label': string;
+    'orderBy.manual': string;
+    'orderBy.updated': string;
+    'sessions.expand': string;
+    'sessions.collapse': string;
+    'empty.none': string;
+    'empty.noMatches': string;
+    'workspace.add': string;
+    'search.sessions.aria': string;
+    'search.placeholder': string;
+    'search.clear': string;
+    'search.results.aria': string;
+    'search.pending': string;
+    'search.unavailable': string;
+    'search.noMatches': string;
+    'search.hasMore': string;
+    'menu.addWorkspace': string;
+    'picker.loading': string;
+    'conflict.named': string;
+    'folderError.title': string;
+    'folderError.retry': string;
+    rename: string;
+    'rename.workspace.title': string;
+    'rename.session.title': string;
+    'field.workspaceName': string;
+    'field.sessionName': string;
+    'delete.workspace': string;
+    'delete.desc': string;
+    'delete.pending': string;
+    'menu.fork': string;
+    'menu.archiveSession': string;
+    'sessions.count.one': string;
+    'sessions.count.other': string;
+    'actions.workspace.aria': string;
+    'actions.session.aria': string;
+    'actions.newSession.aria': string;
+    'status.running': string;
+    'status.subagentsRunning.one': string;
+    'status.subagentsRunning.other': string;
+    'status.idle': string;
+    'status.waitingApproval': string;
+    'status.planReview': string;
+    'status.waitingAnswer': string;
+    'status.completed': string;
+    'hover.created': string;
+    'hover.copied': string;
+    'date.ymd': string;
+    'time.now': string;
+    'time.minutes': string;
+    'time.hours': string;
+    'time.days': string;
+    'time.months': string;
+    'time.years': string;
+    'time.ago': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/navigation.d.ts

@@ -0,0 +1,83 @@
+/** Workspace archive and directory UI capability. */
+import { Service, type Context } from '@prettier-ai/cordis';
+import type { ClientRemote, DirectoryListing } from '@prettier-ai/dsh-api-remotes/client';
+import type { RemoteFailure } from '@prettier-ai/dsh-typert-protocol';
+import type { ISessions } from '@prettier-ai/dsh-api-session-controller/client';
+import type { IWorkspaces, WorkspaceId } from '@prettier-ai/dsh-api-workspace-controller/client';
+import type { SessionId } from '@prettier-ai/dsh-session/types';
+/** Workspace archive and directory operations consumed by Client UI domains. */
+export interface UiWorkspace {
+    /**
+     * Resolve the reusable or newly created blank Session for a Workspace.
+     * @param workspaceId - target Workspace.
+     * @returns a Session already addressable through the Session Controller.
+     */
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    /**
+     * Start a New Session flow and navigate to its Session.
+     * @param workspaceId - explicit target; absent inherits the current or most recent Workspace.
+     */
+    startSession(workspaceId?: WorkspaceId): void;
+    /**
+     * Archive a Session and clear it when it is the current selection.
+     * @param sessionId - Session to archive.
+     */
+    archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Open the Host-native directory picker.
+     * @returns the selected directory, or null when cancelled.
+     */
+    pickDirectory(): Promise<string | null>;
+    /**
+     * List one Host directory level.
+     * @param path - directory path; absent selects the Host home.
+     * @param signal - cancellation for a superseded scan.
+     * @returns directory entries and breadcrumb ancestry.
+     */
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    /**
+     * Create a child directory.
+     * @param path - existing parent directory.
+     * @param name - child directory name.
+     * @returns created absolute path.
+     */
+    createDirectory(path: string, name: string): Promise<string>;
+}
+declare module '@prettier-ai/cordis' {
+    interface Context {
+        /** Cross-Controller Workspace navigation and directory UI capability. */
+        uiWorkspace: UiWorkspace;
+    }
+}
+/** Structured directory failure exposed to directory UI consumers. */
+export declare class DirectoryBrowseError extends Error {
+    readonly rpcError: RemoteFailure;
+    readonly name = "DirectoryBrowseError";
+    /** @param rpcError - Host directory business failure. */
+    constructor(rpcError: RemoteFailure);
+}
+/** Implements Workspace archive and directory UI operations. */
+declare class UiWorkspaceService extends Service implements UiWorkspace {
+    private readonly directoryPicker;
+    private readonly workspaces;
+    private readonly sessions;
+    private readonly connecting;
+    /**
+     * @param ctx - Client root Context.
+     * @param directoryPicker - the directory-picking Remote namespace.
+     * @param workspaces - pure Workspace Controller.
+     * @param sessions - pure Session Controller.
+     */
+    constructor(ctx: Context, directoryPicker: ClientRemote['directoryPicker'], workspaces: IWorkspaces, sessions: ISessions);
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    startSession(workspaceId?: WorkspaceId): void;
+    archiveSession(sessionId: SessionId): Promise<void>;
+    pickDirectory(): Promise<string | null>;
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    createDirectory(path: string, name: string): Promise<string>;
+    private watchNavigation;
+    /** @returns true when an archived current selection was cleared. */
+    private clearArchivedCurrent;
+}
+export { UiWorkspaceService };
+//# sourceMappingURL=navigation.d.ts.map

package/lib/types/client/rows/Rows.d.ts

@@ -0,0 +1,103 @@
+import type { WorkspaceBrowserProps } from '../contract/slots.ts';
+import type { GroupNode, SearchResultNode, SessionNode } from '../tree.ts';
+/** The standard locale seat, prop-passed from the browser root. */
+type RowTranslate = WorkspaceBrowserProps['t'];
+/**
+ * Row drag wiring supplied by the tree owner. `drop` reports the half of the
+ * row where the pointer released so the owner can resolve an insert anchor.
+ */
+export interface RowDragProps {
+    /** Start dragging this row. */
+    start: () => void;
+    /** A compatible row drag is in flight. */
+    active: boolean;
+    /** Current marker on this row: insert line above, below, or none. */
+    marker: 'before' | 'after' | null;
+    /** Report the hovered half while a compatible drag passes over this row. */
+    hover: (half: 'before' | 'after') => void;
+    drop: (half: 'before' | 'after') => void;
+    end: () => void;
+}
+/** Drag lifecycle owned by a workspace row; its enclosing group owns hit testing. */
+interface WorkspaceRowDragProps {
+    start: () => void;
+    end: () => void;
+}
+/**
+ * Project (workspace) header row: folder + title;
+ * hover reveals the chevron and create button, and dwelling on a real
+ * Workspace shows its hover card (the ungrouped bucket has none).
+ * `containsCurrent` arrives on the node (derivation fact, no renderer scan).
+ * @param props.group - derived group node.
+ * @param props.onToggle - expand/collapse the group.
+ * @param props.onCreate - start a frontend Session inside this Workspace.
+ * @param props.drag - optional workspace-row drag wiring.
+ * @param props.home - host account home for POSIX hover-path abbreviation.
+ * @param props.t - the browser root's locale seat.
+ * @returns the row element.
+ */
+export declare function ProjectRowItem({ group, onToggle, onCreate, actions, drag, home, t }: {
+    group: GroupNode;
+    onToggle: () => void;
+    onCreate: () => void;
+    /** Real-Workspace actions; absent for the ungrouped bucket (no menu shown). */
+    actions?: {
+        rename: () => void;
+        delete: () => void;
+    } | undefined;
+    /** Present only for real Workspace rows in the grouped view. */
+    drag?: WorkspaceRowDragProps | undefined;
+    /** Host account home; POSIX home-rooted hover paths display as `~`. */
+    home?: string | undefined;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+/**
+ * One flat search result: title, Workspace context, and optional content
+ * excerpt. Search navigation opens the session only; it does not address an
+ * event inside the conversation.
+ * @param props.result - merged local/content search row.
+ * @param props.currentId - selected session id.
+ * @param props.onOpen - open the selected session.
+ * @param props.t - Workspace-browser translation seat.
+ * @returns the result button.
+ */
+export declare function SearchResultItem({ result, currentId, onOpen, t }: {
+    result: SearchResultNode;
+    currentId: string | undefined;
+    onOpen: (id: SearchResultNode['id']) => void;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+/**
+ * One top-level 34px session row: status dot (pending user interaction outranks
+ * own or descendant activity), title, relative time, and the row actions menu.
+ * @param props.node - derived session node.
+ * @param props.currentId - selected session id (row highlight).
+ * @param props.now - epoch ms for relative-time formatting.
+ * @param props.onOpen - open a session by id.
+ * @param props.onRename - open the session rename dialog (id + current title).
+ * @param props.onFork - fork a session at its last completed turn.
+ * @param props.onArchive - archive a session by id.
+ * @param props.drag - optional draggable-row wiring.
+ * @param props.flat - omit the empty status slot in the hierarchy-free flat list.
+ * @param props.t - the browser root's locale seat.
+ * @returns the session row.
+ */
+export declare function SessionNodeItem({ node, currentId, now, onOpen, onRename, onFork, onArchive, drag, flat, t }: {
+    node: SessionNode;
+    currentId: string | undefined;
+    now: number;
+    onOpen: (id: SessionNode['id']) => void;
+    /** Open the browser-owned session rename dialog (row menu action). */
+    onRename: (id: SessionNode['id'], currentTitle: string) => void;
+    /** Fork a session at its last completed turn (row menu action). */
+    onFork: (id: SessionNode['id']) => void;
+    /** Archive this session (row menu action; commits without a dialog). */
+    onArchive: (id: SessionNode['id']) => void;
+    /** Present only on draggable rows (workspace-group sessions outside search). */
+    drag?: RowDragProps | undefined;
+    /** The row is rendered without a parent Workspace header. */
+    flat?: boolean | undefined;
+    t: RowTranslate;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=Rows.d.ts.map

package/lib/types/client/rows/WorkspaceBrowser.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceBrowserProps } from '../contract/slots.ts';
+/**
+ * Render the browsing region.
+ * @param props - composed slot props (shell owner share + store + injected actions).
+ * @returns the region element tree.
+ */
+export declare function WorkspaceBrowser({ wide, expandSidebar, useSessions, useSessionPendingInteraction, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, insertSessionBefore, createWorkspace, searchSessions, searchResultLimit, useDirectoryFlow, useConnectionGeneration, renderSlot, t, }: WorkspaceBrowserProps): import("react").JSX.Element;
+//# sourceMappingURL=WorkspaceBrowser.d.ts.map