@achasoft/dsh-advanced-sidebar 0.1.0

package/types/client/ui/Toggle.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The kit's two binary controls: a switch for a setting, a checkbox for a row selection.
+ *
+ * Both are `<button role="switch">` / `<button role="checkbox">` rather than a styled
+ * `<input type="checkbox">`. A native checkbox cannot carry the thumb transition without pseudo
+ * elements that no longer expose their state to assistive technology once the input is hidden.
+ * @module @achasoft/dsh-advanced-sidebar/client/ui/Toggle
+ */
+import type { ReactNode } from 'react';
+/** What both binary controls take. */
+export interface ToggleProps {
+    /** Current state. */
+    checked: boolean;
+    /**
+     * The state changed.
+     * @param next - the state after the press.
+     */
+    onCheckedChange: (next: boolean) => void;
+    /** Refuses the press and dims the control. */
+    disabled?: boolean | undefined;
+    /** Accessible name, when no visible label is associated. */
+    'aria-label'?: string | undefined;
+    /** The visible label's element id. */
+    'aria-labelledby'?: string | undefined;
+    /** The control's own id, for a `<label for>`. */
+    id?: string | undefined;
+    /** Additional classes. */
+    className?: string | undefined;
+}
+/**
+ * A switch.
+ * @param props - the state, the change callback, and the accessibility attributes.
+ * @returns the switch element.
+ * @see {@link ToggleProps}
+ */
+export declare function Switch(props: ToggleProps): import("react").JSX.Element;
+/**
+ * A checkbox.
+ * @param props - the state, the change callback, and the accessibility attributes.
+ * @returns the checkbox element.
+ * @see {@link ToggleProps}
+ */
+export declare function Checkbox(props: ToggleProps): import("react").JSX.Element;
+/**
+ * A checkbox with its label, as one click target.
+ * @param props.checked - current state.
+ * @param props.onCheckedChange - the state changed.
+ * @param props.disabled - refuses the press.
+ * @param props.children - the label.
+ * @returns the labelled checkbox.
+ */
+export declare function CheckboxRow(props: {
+    checked: boolean;
+    onCheckedChange: (next: boolean) => void;
+    disabled?: boolean | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/types/client/ui/Tooltip.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The kit's tooltip: a hover/focus label placed with the same collision handling as every other
+ * layer, so a control at the dock's right edge does not describe itself off screen.
+ * @module @achasoft/dsh-advanced-sidebar/client/ui/Tooltip
+ */
+import type { ReactElement, ReactNode } from 'react';
+import type { Side } from './anchor.ts';
+/**
+ * A tooltip around one child.
+ *
+ * The child is wrapped rather than cloned: cloning would need to merge a ref and four handlers into
+ * whatever the caller passed, and a wrapper that lays out as its child costs nothing.
+ * @param props.label - the text; an empty label renders the child alone.
+ * @param props.side - preferred edge, flipped when the window cannot hold it there.
+ * @param props.children - the element being described.
+ * @returns the wrapped child, and the label while it is showing.
+ */
+export declare function Tooltip({ label, side, children }: {
+    label: string;
+    side?: Side | undefined;
+    children: ReactElement | ReactNode;
+}): import("react").JSX.Element;

package/types/client/ui/anchor.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Collision-aware placement for every layer this package floats above the page: the action menu,
+ * its submenus, the select lists, the date picker, and the tooltips.
+ *
+ * The harness's own `Menu` primitive clamps a root list into the viewport but pins a submenu at
+ * `left: calc(100% + 10px)` with no flip, so a menu opened near the right edge pushes its submenu
+ * off screen. Placement here is a pure function of four rectangles, which is what makes the flip
+ * decision testable and identical for every layer that uses it.
+ * @module @achasoft/dsh-advanced-sidebar/client/ui/anchor
+ */
+import type { CSSProperties, MutableRefObject } from 'react';
+/** Which edge of the anchor the layer prefers to sit against. */
+export type Side = 'top' | 'right' | 'bottom' | 'left';
+/** Where the layer lines up along that edge. */
+export type Align = 'start' | 'center' | 'end';
+/** A rectangle in viewport coordinates; the browser's `DOMRect` satisfies it. */
+export interface Box {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** How one layer wants to sit against its anchor. */
+export interface PlacementRequest {
+    /** Preferred edge; flipped to its opposite when the layer does not fit there. */
+    readonly side: Side;
+    /** Preferred alignment along that edge. */
+    readonly align: Align;
+    /** Gap between the anchor edge and the layer, in pixels. */
+    readonly sideOffset: number;
+    /** Shift along the alignment axis before collision handling, in pixels. */
+    readonly alignOffset: number;
+    /** Clearance kept from every viewport edge, in pixels. */
+    readonly padding: number;
+}
+/** Where a layer ended up, and how much room it was given. */
+export interface Placement {
+    /** Viewport x of the layer's left edge. */
+    readonly left: number;
+    /** Viewport y of the layer's top edge. */
+    readonly top: number;
+    /** The edge actually used, after any flip. */
+    readonly side: Side;
+    /** The alignment actually used, after any flip. */
+    readonly align: Align;
+    /** Largest height the layer may occupy at this position; it scrolls internally past it. */
+    readonly maxHeight: number;
+}
+/** The default request; every layer overrides only what differs. */
+export declare const DEFAULT_PLACEMENT: PlacementRequest;
+/**
+ * Place one layer against its anchor, flipping to the opposite side when it does not fit and
+ * shifting along the other axis to stay inside the viewport.
+ *
+ * The flip is taken only when the opposite side has strictly more room: a layer that fits nowhere
+ * keeps the side it asked for and is capped by {@link Placement.maxHeight} instead of jumping to a
+ * side that is just as short.
+ * @param anchor - the trigger's rectangle, in viewport coordinates.
+ * @param layer - the layer's measured size.
+ * @param viewport - the viewport rectangle.
+ * @param request - the preferred side, alignment, gaps, and clearance.
+ * @returns where to position the layer and how tall it may be.
+ */
+export declare function placeLayer(anchor: Box, layer: {
+    readonly width: number;
+    readonly height: number;
+}, viewport: Box, request: PlacementRequest): Placement;
+/** A measured, positioned layer plus the trigger to re-measure it. */
+export interface AnchoredLayer {
+    /** Attach to the floating element; its box is what placement measures. */
+    readonly ref: MutableRefObject<HTMLDivElement | null>;
+    /** Fixed-position style for the floating element, including its height cap. */
+    readonly style: CSSProperties;
+    /** The edge the layer ended up on, for a directional entry animation. */
+    readonly side: Side;
+    /** Re-measure and reposition now; safe to call from a layout effect. */
+    readonly place: () => void;
+}
+/**
+ * Position one floating element against a caller-owned anchor rectangle.
+ *
+ * The first placement runs in a layout effect against the hidden pre-render, so the first painted
+ * frame is already final — a layer that measured zero and corrected itself afterwards visibly
+ * jumps. While open, scroll (captured, so a scrolling pane counts) and resize re-place it.
+ * @param open - whether the layer is rendered; closed suspends every listener.
+ * @param getAnchorRect - the anchor's current rectangle; null skips placement for that frame.
+ * @param request - overrides of {@link DEFAULT_PLACEMENT}.
+ * @returns the ref, the style, the resolved side, and a manual re-place.
+ */
+export declare function useAnchoredLayer(open: boolean, getAnchorRect: () => DOMRect | null, request?: Partial<PlacementRequest>): AnchoredLayer;

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

@@ -0,0 +1,42 @@
+/**
+ * The shadcn-vocabulary component kit this plugin's surfaces are built from.
+ *
+ * shadcn/ui cannot be installed into an out-of-tree browser half: it is Tailwind utilities over
+ * Radix primitives, and this package ships as one bundled CSS-Modules file with no Tailwind
+ * pipeline and no second React runtime to give Radix. What is reproduced is the vocabulary — the
+ * variant and size axes, the geometry scale, the flat bordered surfaces, and the focus ring — over
+ * the harness's own design tokens, so the components sit in the app's themes unmodified.
+ *
+ * They are also what fixes the menu: every floating surface is placed through the collision
+ * handling in {@link module:@achasoft/dsh-advanced-sidebar/client/ui/anchor}, which the harness's
+ * `Menu` primitive applies to a root list but not to a submenu.
+ * @module @achasoft/dsh-advanced-sidebar/client/ui
+ */
+export { Alert } from './Alert.tsx';
+export type { AlertProps, AlertTone } from './Alert.tsx';
+export { Badge } from './Badge.tsx';
+export type { BadgeProps, BadgeVariant } from './Badge.tsx';
+export { Button } from './Button.tsx';
+export type { ButtonProps, ButtonSize, ButtonVariant } from './Button.tsx';
+export { Calendar, dayKey, monthGrid, startOfDay } from './Calendar.tsx';
+export type { CalendarProps } from './Calendar.tsx';
+export { DatePicker } from './DatePicker.tsx';
+export type { DatePickerProps } from './DatePicker.tsx';
+export { AlertDialog, Dialog } from './Dialog.tsx';
+export type { DialogProps } from './Dialog.tsx';
+export { DropdownMenu } from './DropdownMenu.tsx';
+export type { DropdownMenuProps, MenuItemNode, MenuLabelNode, MenuNode, MenuSeparatorNode, MenuSubNode, } from './DropdownMenu.tsx';
+export { Input, Textarea } from './Input.tsx';
+export type { InputProps } from './Input.tsx';
+export { Layer, insideLayerTree } from './Layer.tsx';
+export type { LayerProps } from './Layer.tsx';
+export { Select } from './Select.tsx';
+export type { SelectOption, SelectProps } from './Select.tsx';
+export { Separator } from './Separator.tsx';
+export { Tabs } from './Tabs.tsx';
+export type { TabDescriptor, TabsProps } from './Tabs.tsx';
+export { Checkbox, CheckboxRow, Switch } from './Toggle.tsx';
+export type { ToggleProps } from './Toggle.tsx';
+export { Tooltip } from './Tooltip.tsx';
+export { DEFAULT_PLACEMENT, placeLayer, useAnchoredLayer } from './anchor.ts';
+export type { Align, AnchoredLayer, Box, Placement, PlacementRequest, Side } from './anchor.ts';

package/types/client/use-capability.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The capability-view hook shared by the two menu seats and the settings card.
+ *
+ * There is no host-to-client push channel available to an out-of-tree plugin, so the view is
+ * fetched rather than subscribed. It is fetched on demand — when a menu opens, when a card is
+ * expanded — rather than on a timer: the facts it carries (is git installed, does `code` resolve)
+ * change on the scale of an operator installing something, and a poll would spend a PATH scan per
+ * interval to notice.
+ * @module @achasoft/dsh-advanced-sidebar/client/use-capability
+ */
+import type { AdvancedSidebarView } from '../host/types.ts';
+/** The view plus the trigger that re-reads it. */
+export interface CapabilityHandle {
+    /** The last successful reading; undefined until one arrives. */
+    view: AdvancedSidebarView | undefined;
+    /** The transport failure of the last attempt, when it failed. */
+    error: string | undefined;
+    /** Ask for a fresh reading. Stable across renders, so it is safe in an effect's dependency list. */
+    refresh: () => void;
+}
+/**
+ * Read the Host capability view on demand.
+ * @param describe - the endpoint call.
+ * @param enabled - false suspends fetching entirely (a collapsed card, a seat switched off).
+ * @returns the view, the last error, and a stable refresh.
+ */
+export declare function useCapabilityView(describe: (signal?: AbortSignal) => Promise<AdvancedSidebarView>, enabled?: boolean): CapabilityHandle;

package/types/host/deletion.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Session deletion.
+ *
+ * No harness capability deletes a session: session persistence is append-only and exposes no delete
+ * verb, and the workspace registry can only ARCHIVE — hide a session while keeping its log and its
+ * accounting slot. Delete is therefore assembled here from the two things that do exist, and it is
+ * honest about which one it managed:
+ *
+ * - `archive` hides the session. Reversible in principle (the durable slot is preserved), and the
+ *   only mode that can act on a session that is currently live.
+ * - `purge` additionally removes the persistence backend's own per-session artifact. Nothing undoes
+ *   that, and a backend that keeps no per-session artifact (SQLite) reports the archive alone.
+ *
+ * A live session is never purged. Its writer holds the artifact open and a running turn would keep
+ * appending to a file that no longer exists, so the archive commits and the reason is returned.
+ * @module @achasoft/dsh-advanced-sidebar/host/deletion
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AdvancedSidebarSettings, DeleteSessionRequest, DeleteSessionResult } from './types.ts';
+/** What Delete can do on this Host right now. */
+export interface DeletionCapability {
+    /** Whether the persistence backend exposes a per-session artifact that could be removed. */
+    readonly canPurge: boolean;
+    /** Why purging is unavailable, when it is. */
+    readonly reason?: string;
+}
+/**
+ * Commits Delete for the sidebar menu. Stateless apart from the context and settings it reads.
+ */
+export declare class SessionDeleter {
+    private readonly ctx;
+    private readonly source;
+    /**
+     * @param ctx - Host context carrying the workspace registry and session persistence.
+     * @param source - reads the current settings section; called per request.
+     */
+    constructor(ctx: Context, source: () => AdvancedSidebarSettings);
+    /**
+     * Report whether the durable log can be removed at all.
+     * @returns the capability, with a reason when purging is impossible.
+     */
+    describe(): DeletionCapability;
+    /**
+     * Hide one session, and remove its durable artifact when the mode and the Host allow it.
+     * @param request - the session to delete.
+     * @param signal - cancellation for the persistence listing.
+     * @returns what was actually done, or a classified failure.
+     */
+    delete(request: DeleteSessionRequest, signal?: AbortSignal): Promise<DeleteSessionResult>;
+    /**
+     * Find the backend artifact for one session, or say why it will not be removed.
+     * @param sessionId - the session to look up.
+     * @param signal - cancellation for the persistence listing.
+     * @returns the artifact path, or the reason purging is skipped.
+     */
+    private locateArtifact;
+}

package/types/host/files.d.ts

@@ -0,0 +1,43 @@
+/**
+ * File previews for the Files panel.
+ *
+ * Directory listing is not here: the Web Client already reaches the Host's own `browse` capability
+ * through `ctx.workspaces.listDirectory`, so the panel walks the tree with the same capability the
+ * workspace picker uses and this module owns only the read that surface has no verb for.
+ * @module @achasoft/dsh-advanced-sidebar/host/files
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AdvancedSidebarSettings, CapabilityState, ListEntriesRequest, ListEntriesResult, ReadFileRequest, ReadFileResult } from './types.ts';
+/** Reads file previews for the Files panel. */
+export declare class FileReader {
+    private readonly ctx;
+    private readonly source;
+    /**
+     * @param ctx - Host context carrying the optional filesystem capability.
+     * @param source - reads the current settings section; called per request.
+     */
+    constructor(ctx: Context, source: () => AdvancedSidebarSettings);
+    /**
+     * Report whether a preview can be read on this Host.
+     * @returns availability, with the reason when there is no filesystem.
+     */
+    describe(): CapabilityState;
+    /**
+     * List one directory level inside a workspace.
+     *
+     * The Web Client's own `listDirectory` cannot serve this panel: the Host's browse capability
+     * returns directories only, because its one caller is a workspace picker. A file browser needs
+     * the files.
+     * @param request - the directory and the workspace it must stay inside.
+     * @param signal - cancellation for the listing.
+     * @returns the level, or a classified failure.
+     */
+    list(request: ListEntriesRequest, signal?: AbortSignal): Promise<ListEntriesResult>;
+    /**
+     * Read one file, bounded by `filesMaxPreviewBytes`.
+     * @param request - the file and the workspace it must stay inside.
+     * @param signal - cancellation for the read.
+     * @returns the preview, or a classified failure.
+     */
+    read(request: ReadFileRequest, signal?: AbortSignal): Promise<ReadFileResult>;
+}

package/types/host/git.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Git readings for the Changes panel.
+ *
+ * The harness has no git capability, so this reads a repository the only way available to a plugin:
+ * by running `git` through `ctx.subprocess` and parsing its machine formats. Nothing here writes to
+ * a repository — the panel shows what changed and what one path's patch looks like, and every
+ * argument list is fixed here rather than assembled from browser text.
+ * @module @achasoft/dsh-advanced-sidebar/host/git
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AdvancedSidebarSettings, CapabilityState, GitCommitMessageRequest, GitCommitMessageResult, GitCommitRequest, GitCommitResult, GitDiffRequest, GitDiffResult, GitPushRequest, GitPushResult, GitStageRequest, GitStageResult, GitStatusRequest, GitStatusResult } from './types.ts';
+/**
+ * Take a model's answer down to the message itself.
+ *
+ * A model asked for plain text still fences it often enough that the panel would otherwise put
+ * ```` ``` ```` into a commit; the wrapper is removed only when it wraps the WHOLE answer, so a
+ * message that legitimately quotes a fenced block keeps it.
+ * @param text - what the model streamed.
+ * @returns the message, trimmed.
+ */
+export declare function stripFence(text: string): string;
+/**
+ * Reads one workspace's git state. One instance serves every request; the resolved `git` path is
+ * cached across calls and dropped whenever a lookup fails, so installing git later needs no restart.
+ */
+export declare class GitReader {
+    private readonly ctx;
+    private readonly source;
+    private executable;
+    private version;
+    /**
+     * @param ctx - Host context carrying the subprocess and filesystem capabilities.
+     * @param source - reads the current settings section; called per request so a committed change
+     * reaches the next reading with no registration to rebuild.
+     */
+    constructor(ctx: Context, source: () => AdvancedSidebarSettings);
+    /**
+     * Report whether git can answer on this Host.
+     * @param signal - cancellation for the lookup.
+     * @returns availability plus the version string when one was read.
+     */
+    describe(signal?: AbortSignal): Promise<CapabilityState>;
+    /**
+     * Read one workspace's changed paths.
+     * @param request - the workspace directory to read.
+     * @param signal - cancellation for the reading.
+     * @returns the reading, or a classified failure.
+     */
+    status(request: GitStatusRequest, signal?: AbortSignal): Promise<GitStatusResult>;
+    /**
+     * Read one path's patch.
+     * @param request - which path, and which of the two indexes to compare.
+     * @param signal - cancellation for the reading.
+     * @returns the patch, or a classified failure.
+     */
+    diff(request: GitDiffRequest, signal?: AbortSignal): Promise<GitDiffResult>;
+    /**
+     * Stage paths.
+     * @param request - the workspace and the repository-relative paths to add.
+     * @param signal - cancellation for the write and the reading that follows it.
+     * @returns the reading after the write, or a classified failure.
+     */
+    stage(request: GitStageRequest, signal?: AbortSignal): Promise<GitStageResult>;
+    /**
+     * Unstage paths, leaving the working tree untouched.
+     * @param request - the workspace and the repository-relative paths to restore.
+     * @param signal - cancellation for the write and the reading that follows it.
+     * @returns the reading after the write, or a classified failure.
+     */
+    unstage(request: GitStageRequest, signal?: AbortSignal): Promise<GitStageResult>;
+    /**
+     * Record the staged changes.
+     *
+     * The message crosses as one argv element, so no shell ever sees it and nothing in it can become
+     * an option. Hooks run: a `pre-commit` that refuses is a real answer, and its stderr is returned
+     * verbatim rather than summarized.
+     * @param request - the workspace, the message, and whether to replace the previous commit.
+     * @param signal - cancellation for the commit and the reading that follows it.
+     * @returns the new commit and the reading after it, or a classified failure.
+     */
+    commit(request: GitCommitRequest, signal?: AbortSignal): Promise<GitCommitResult>;
+    /**
+     * Send the current branch's commits to its remote.
+     *
+     * Only the current branch, and only to its own upstream: a refspec assembled from browser text
+     * would let one button push anything anywhere, and `git push` with no arguments already means
+     * exactly what the panel offers. A branch with no upstream is published only when the caller asks
+     * for it, because choosing a remote is a decision rather than a default.
+     * @param request - the workspace, and whether an unpublished branch may be published.
+     * @param signal - cancellation; the network wait runs under `gitPushTimeoutMs`.
+     * @returns the push, the reading after it, or a classified failure.
+     */
+    push(request: GitPushRequest, signal?: AbortSignal): Promise<GitPushResult>;
+    /**
+     * Ask the deployment's own model to write a commit message for what is staged.
+     *
+     * The model sees the staged patch and nothing else — not the working tree, not the repository's
+     * history, not the session. It is the same model the composer is set to, so this needs no second
+     * credential and no second provider; a Host with no model reports the verb unavailable instead.
+     * @param request - the workspace, and whether the message is for an amend.
+     * @param signal - cancellation for the readings and the model call.
+     * @returns the drafted message, or a classified failure.
+     */
+    draftCommitMessage(request: GitCommitMessageRequest, signal?: AbortSignal): Promise<GitCommitMessageResult>;
+    /**
+     * The patch a drafted message describes, bounded so a large change cannot become a large request.
+     * @param root - absolute repository root.
+     * @param amend - describe the previous commit's content as well as the index.
+     * @param signal - cancellation for the invocations.
+     * @returns the patch and whether it was cut, or the failure to return.
+     */
+    private stagedPatch;
+    /**
+     * Whether HEAD has a parent commit.
+     * @param cwd - absolute repository root.
+     * @param signal - cancellation for the invocation.
+     * @returns true when `HEAD~1` resolves.
+     */
+    private hasParent;
+    /**
+     * The remote an unpublished branch would be published to.
+     * @param cwd - absolute repository root.
+     * @param signal - cancellation for the invocation.
+     * @returns `origin` when it exists, else the first remote, else undefined.
+     */
+    private defaultRemote;
+    /**
+     * Run one index write over contained paths, then re-read the repository.
+     * @param request - the workspace and the paths.
+     * @param signal - cancellation for both invocations.
+     * @param argv - builds the git arguments from the accepted paths.
+     * @returns the reading after the write, or a classified failure.
+     */
+    private write;
+    /**
+     * Prove every path sits inside the repository before git is handed any of them.
+     *
+     * A path from the browser is untrusted input at a process boundary. `git add` and
+     * `git restore` both accept absolute paths and `..`, and `git diff --no-index` will read any file
+     * at all — so an unchecked path is a write outside the repository in one direction and an
+     * exfiltration route in the other.
+     * @param root - absolute repository root.
+     * @param paths - repository-relative paths, as the browser sent them.
+     * @param signal - cancellation for the resolutions.
+     * @returns the failure to return, or undefined when every path is inside.
+     */
+    private contain;
+    /**
+     * The author `git commit` would record.
+     * @param cwd - the repository root.
+     * @param signal - cancellation for the invocation.
+     * @returns `Name <email>`, or undefined when git has no identity configured.
+     */
+    private author;
+    /**
+     * Whether the index differs from HEAD.
+     * @param cwd - the repository root.
+     * @param signal - cancellation for the invocation.
+     * @returns true when a commit would record something.
+     */
+    private hasStaged;
+    /**
+     * Report what the panel may do to this repository.
+     * @param cwd - the repository root.
+     * @param signal - cancellation for the identity lookup.
+     * @returns the write capability.
+     */
+    private writeCapability;
+    /**
+     * Resolve the workspace and its repository once for both endpoints.
+     * @param workspacePath - the browser-supplied directory.
+     * @param signal - cancellation for the resolution and the `rev-parse`.
+     * @returns the repository and the resolved workspace, or the failure to return.
+     */
+    private prepare;
+    /**
+     * Ask git where the repository containing a directory begins.
+     * @param cwd - the canonical workspace directory.
+     * @param signal - cancellation for the invocation.
+     * @returns the repository, or the failure to return.
+     */
+    private locateRepository;
+    /**
+     * Run one git invocation with this plugin's own bounds.
+     * @param cwd - directory to run in.
+     * @param args - arguments after the executable.
+     * @param signal - the caller's cancellation.
+     * @returns the finished command.
+     */
+    private git;
+    /**
+     * Resolve `git` once and remember it.
+     * @param signal - cancellation for the lookup.
+     * @returns the executable path, or undefined when git is absent.
+     * @throws {CommandUnavailableError} when no subprocess capability is mounted.
+     */
+    private locate;
+}