@qilin-agent/client-ui-agent-preset 0.0.0-stage → 3.1.3

package/lib/index.js

@@ -0,0 +1,11 @@
+//#region lib/types/index.js
+/**
+* Agent-preset surface plugin, node half. The empty apply exists so the plugin
+* appears in the host cordis.yml / Loader; the browser half ships the
+* General-settings row through exports["./client"], discovered from the
+* package.json qilin.client declaration.
+*/
+/** Host plugin body — no host-side behavior for this surface plugin. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,30 @@
+/**
+ * The session header's agent-preset label.
+ *
+ * Read-only by construction: a session's composition is fixed once its
+ * conversation starts, and a header is only worth reading after that. Offering
+ * a control here would promise a switch the host refuses; naming what the
+ * session runs is the honest affordance, and the choice itself lives on the
+ * new-session screen ({@link AgentPresetSeat}).
+ */
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { AgentPresetSettingsState } from './settings-store.ts';
+/** Registration-side business face for the header label. */
+export interface AgentPresetLabelInjected {
+    hooks: {
+        /** Roster snapshot bound by the renderer as useAgentPresets. */
+        agentPresets: SnapshotStore<AgentPresetSettingsState>;
+    };
+    /** Read the roster, so the label can show a name rather than an id. */
+    load: () => Promise<void>;
+}
+/** Full component props. */
+export type AgentPresetLabelProps = PropsRuntime<'conversation.session.header.actions'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetLabelInjected>;
+/**
+ * Render this session's agent-preset name beside its title.
+ * @param props - composed slot props.
+ * @returns the label, or null when the session records no preset.
+ */
+export declare function AgentPresetLabel({ sessionId, useSessions, useAgentPresets, load, t, }: AgentPresetLabelProps): import("react").JSX.Element | null;
+//# sourceMappingURL=AgentPresetLabel.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * The agent-preset chip on the new-session screen, beside the workspace
+ * picker.
+ *
+ * It lives here rather than in the composer because the choice is only
+ * available before a conversation starts: once a turn has run, the session's
+ * history was produced under that preset's tools and the host refuses to swap
+ * them. A control that spends most of its life disabled belongs on the screen
+ * where it still works.
+ *
+ * The menu opens on the staged choice, which starts as the deployment default.
+ * Picking stages; the choice reaches a session when one becomes current.
+ */
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { AgentPresetSeatState } from './seat-store.ts';
+/** Registration-side business face for the hero chip. */
+export interface AgentPresetSeatInjected {
+    hooks: {
+        /** Seat snapshot bound by the renderer as useAgentPresetSeat. */
+        agentPresetSeat: SnapshotStore<AgentPresetSeatState>;
+    };
+    /** Read the roster when the chip first renders. */
+    load: () => Promise<void>;
+    /** Stage one preset for the next session; resolves to a refusal, or undefined. */
+    select: (id: string) => Promise<string | undefined>;
+    /** Acknowledge the refusal whose Toast finished. */
+    dismissRefusal: (error: AgentPresetSeatState['error']) => void;
+    /** Clear the one-shot introduce cue once the chip has played it. */
+    introduced: () => void;
+}
+/** Full component props. */
+export type AgentPresetSeatProps = PropsRuntime<'conversation.hero.agentPreset'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetSeatInjected>;
+/**
+ * Render the new-session agent-preset chip.
+ * @param props - composed slot props.
+ * @returns the chip and any pending selection refusal, or null outside the main view.
+ */
+export declare function AgentPresetSeat({ sessionId, useSessionRetainInfo, load, select, dismissRefusal, introduced, useAgentPresetSeat, t, }: AgentPresetSeatProps): import("react").JSX.Element | null;
+//# sourceMappingURL=AgentPresetSeat.d.ts.map

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

@@ -0,0 +1,63 @@
+/**
+ * Agent-presets settings section: the roster as cards, a copy dialog as the
+ * only way a preset is created, and a read-only viewer over the shipped
+ * compositions.
+ *
+ * The browser edits no composition text — a shipped preset opens read-only to
+ * be READ (it is the known-good composition a copy starts from), and a custom
+ * preset is edited in its own files, which is what the location action leads
+ * to. Deleting a preset leaves running sessions alone: a composition is
+ * mounted once at session creation and nothing re-reads the file.
+ */
+import type { ReactNode } from 'react';
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import { type AgentPresetSectionState } from './section-store.ts';
+/** Registration-side business face for the management section. */
+export interface AgentPresetSectionInjected {
+    hooks: {
+        /** Page snapshot bound by the renderer as useAgentPresetSection. */
+        agentPresetSection: SnapshotStore<AgentPresetSectionState>;
+    };
+    /** Read the roster; called once when the section first renders. */
+    load: () => Promise<void>;
+    /** Open one shipped preset's composition in the read-only viewer. */
+    view: (id: string) => Promise<void>;
+    /** Close the read-only viewer. */
+    closeView: () => void;
+    /** Open the copy dialog over one preset. */
+    beginCopy: (from: string) => void;
+    /** Close the copy dialog, discarding the draft. */
+    cancelCopy: () => void;
+    /** Name the preset the copy creates. */
+    setCopyId: (id: string) => void;
+    /** Name the copy's display name. */
+    setCopyName: (name: string) => void;
+    /** Submit the copy. */
+    confirmCopy: () => Promise<void>;
+    /** Open one preset's directory, or reveal its path where there is no desktop. */
+    openLocation: (id: string) => Promise<void>;
+    /**
+     * Stage the self-referential preset and start a new session on it — the
+     * guided way to author a preset, beside copying. Absent when the surface
+     * is composed without the conversation flow to land the session in.
+     */
+    startCreatorDraft?: () => void;
+    /** Ask for delete confirmation, or dismiss it with null. */
+    confirmDelete: (id: string | null) => void;
+    /** Delete the preset awaiting confirmation. */
+    remove: () => Promise<void>;
+    /** Make one preset the default for sessions created later. */
+    makeDefault: (id: string) => Promise<void>;
+    /** Show or hide preset selection on new-session surfaces. */
+    setPickerVisible: (showPicker: boolean) => Promise<void>;
+}
+/** Full component props. */
+export type AgentPresetSectionProps = PropsRuntime<'settings.section'> & PropsLocale<'settings.agentPreset'> & InjectFace<AgentPresetSectionInjected>;
+/**
+ * Render the Agent presets section content column.
+ * @param props - composed slot props.
+ * @returns the section, or null when the deployment composes no presets.
+ */
+export declare function AgentPresetSection(props: AgentPresetSectionProps): ReactNode;
+//# sourceMappingURL=AgentPresetSection.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { AgentPresetSettingsState } from './settings-store.ts';
+/** Roster and navigation supplied by the preset plugin. */
+export interface CreatePluginMenuItemInjected {
+    hooks: {
+        agentPresets: SnapshotStore<AgentPresetSettingsState>;
+    };
+    load: () => Promise<void>;
+    startCreatorDraft: () => void;
+}
+type CreatePluginMenuItemProps = PropsRuntime<'plugins.add.actions'> & PropsLocale<'settings.agentPreset'> & InjectFace<CreatePluginMenuItemInjected>;
+/**
+ * Close the Add plugin menu before opening Creator without sending a message;
+ * the draft the visitor typed stays until they send it.
+ * @param props - locale, roster, dismissal and navigation callbacks.
+ * @returns a stable menu item that explains why Creator is unavailable.
+ */
+export declare function CreatePluginMenuItem({ t, useAgentPresets, load, onDismiss, startCreatorDraft, }: CreatePluginMenuItemProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=CreatePluginMenuItem.d.ts.map

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

@@ -0,0 +1,36 @@
+/**
+ * Agent-preset surface plugin, browser half — three surfaces over one roster:
+ * a chip on the new-session screen for the session about to start, a
+ * read-only label in the session header, and a settings section that manages
+ * the roster (copy, delete, default, and the way into a preset's own files).
+ *
+ * A running session keeps the composition it began with (the host refuses to
+ * adopt an existing session under a different preset). That is what splits
+ * the choice from the display: the hero chip is before-the-fact, while the
+ * header only reports what a session already runs. The default preset is
+ * edited where the roster is visible — the settings section's "make default"
+ * — so General settings carries no duplicate control for the same field.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import { type AgentPresetSettingsKey } from './locales.ts';
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Agent-preset surface copy. */
+        'settings.agentPreset': AgentPresetSettingsKey;
+    }
+}
+export type { AgentPresetLabelInjected, AgentPresetLabelProps } from './AgentPresetLabel.tsx';
+export type { AgentPresetSeatInjected, AgentPresetSeatProps } from './AgentPresetSeat.tsx';
+export type { AgentPresetSectionInjected, AgentPresetSectionProps } from './AgentPresetSection.tsx';
+export type { AgentPresetSeatState } from './seat-store.ts';
+export { draftBlocker, type AgentPresetSectionState, type CopyDraft, type PresetRow, type PresetView, } from './section-store.ts';
+export type { AgentPresetOption, AgentPresetSettingsState } from './settings-store.ts';
+export { AGENT_PRESET_SETTINGS_NS, writeDefaultPreset } from './settings-store.ts';
+/** Required services (cordis fiber inject). */
+export declare const inject: string[];
+/**
+ * Mount the roster surfaces: hero chip, session-header label, settings section.
+ * @param ctx - the browser plugin context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+/** Locale bundles for the agent-preset hero chip, header label, and management section. */
+/** Locale keys these surfaces render. */
+export type AgentPresetSettingsKey = 'error' | 'userTrust' | 'seatHint' | 'headerHint' | 'nav' | 'sectionIntro' | 'builtIn' | 'setDefault' | 'view' | 'presetStandardName' | 'presetStandardDescription' | 'presetPtcName' | 'presetPtcDescription' | 'presetCordisName' | 'presetCordisDescription' | 'duplicate' | 'duplicateUnavailable' | 'delete' | 'presetId' | 'presetIdPlaceholder' | 'copyOf' | 'displayName' | 'displayNamePlaceholder' | 'inUse' | 'selectionOffDefault' | 'noDescription' | 'builtInGroup' | 'customGroup' | 'brokenBadge' | 'brokenNoCopy' | 'switchRefused' | 'composition' | 'cancel' | 'close' | 'retry' | 'copyTitle' | 'copyIntro' | 'create' | 'creating' | 'creatorDraft' | 'createPlugin' | 'createPluginDescription' | 'createPluginChecking' | 'createPluginUnavailable' | 'createPluginMissing' | 'openLocation' | 'showLocation' | 'revealedPathLabel' | 'idRequired' | 'idInvalid' | 'idTaken' | 'deleteTitle' | 'deleteDescription' | 'deleteConfirm' | 'deleting' | 'showPicker' | 'showPickerBeta' | 'showPickerDescription' | 'enablePickerToSetDefault' | 'enablePickerToCreate';
+/** English copy. */
+export declare const en: Record<AgentPresetSettingsKey, string>;
+/** Simplified Chinese copy. */
+export declare const zh: Record<AgentPresetSettingsKey, string>;
+export { presetDisplayText } from '@qilin-agent/agent-presets/display';
+export type { PresetDisplaySource, PresetDisplayText } from '@qilin-agent/agent-presets/display';
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/seat-store.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Hero-chip controller: which preset the NEXT session gets.
+ *
+ * The new-session screen has no session, so a pick is staged rather than
+ * applied. It reaches a session when one becomes current and is still blank —
+ * whether the workspace connect created it or reused an existing blank one,
+ * which is why staging cannot simply ride along on `sessions.create`.
+ *
+ * The stage is forgotten once applied. The next new session starts from the
+ * Host-effective default again.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import type { SessionSummary } from '@qilin-agent/api-session-controller/client';
+import { type SnapshotStore } from '@qilin-agent/client-store';
+import type { AgentPresetOption } from './settings-store.ts';
+/** Hero-chip snapshot. */
+export interface AgentPresetSeatState {
+    /** Whether the new-session surface exposes preset selection. */
+    showPicker: boolean;
+    /** Presets the deployment supplies; empty means the chip renders nothing. */
+    options: readonly AgentPresetOption[];
+    /** The staged choice, empty until the roster loads. */
+    current: string;
+    /** An error message; explicit selection failures also carry the preset for a Toast. */
+    error: string | {
+        readonly preset: AgentPresetOption;
+        readonly reason: string;
+    } | null;
+    busy: boolean;
+    /**
+     * One-shot cue that the chip should introduce itself (the creator-draft
+     * entry staged the pick from another screen, so the user never touched the
+     * chip); the renderer clears it via `introduced()` once played.
+     */
+    introduce: boolean;
+}
+/** Mutable one-shot preset choice shared across Provider-bound seat controllers. */
+export interface AgentPresetStage {
+    /** Preset awaiting application; absence means no staged choice. */
+    id: string | undefined;
+    /** Whether the receiving chip should announce the applied choice once. */
+    introduce: boolean;
+}
+/** Stages the next session's preset and applies it when one appears. */
+export declare class AgentPresetSeatController {
+    private readonly ctx;
+    /** The session the hero is about to hand over to, when there is one. */
+    private readonly currentSession;
+    private readonly staged;
+    /** Chip snapshot the renderer subscribes to. */
+    readonly store: SnapshotStore<AgentPresetSeatState>;
+    /**
+     * The Host-effective default, so a consumed stage can fall back to it without
+     * re-reading the roster.
+     */
+    private fallback;
+    /** Only the newest roster read may publish after overlapping refreshes. */
+    private loadGeneration;
+    constructor(ctx: ClientContext, 
+    /** The session the hero is about to hand over to, when there is one. */
+    currentSession: () => Pick<SessionSummary, 'id' | 'blank' | 'projectionValues'> | undefined, staged?: AgentPresetStage);
+    private set;
+    /**
+     * Read the roster and open the chip on the Host-effective default.
+    * @returns once the snapshot reflects the host.
+    */
+    load(): Promise<void>;
+    /**
+     * Stage one preset for the next session, applying it immediately when a
+     * blank session is already current.
+     *
+     * The refusal is returned as well as stored, because the two readers need
+     * different things from it: the chip's own label carries the standing state,
+     * while the caller that made this pick is the one that has to say why the
+     * label came back — and only it knows the pick was a person's, not the
+     * applier catching up with a session that just became current.
+     * @param id - the preset to stage.
+     * @returns the refusal text, or undefined once the pick settled.
+     */
+    select(id: string): Promise<string | undefined>;
+    /**
+     * Stage a pick WITHOUT the immediate apply, for a flow that starts the
+     * receiving session after the pick (the settings section's creator entry).
+     * `select()`'s immediate apply would meet the still-current running session
+     * and drop the stage as unservable; staging alone leaves it for the
+     * list-change applier, which fires when the started session becomes
+     * current.
+     * @param id - the preset to stage.
+     * @param introduce - true when the stage came from another screen and the
+     * chip should announce itself on the session it lands on.
+     */
+    stage(id: string, introduce?: boolean): void;
+    /**
+     * Capture the exact blank Session a Settings action may bring along.
+     * @returns its id, or undefined outside a blank Session.
+     */
+    blankSessionId(): SessionSummary['id'] | undefined;
+    /**
+     * Apply a Settings choice only if its captured Session is still current and
+     * blank. The selection uses the existing stage/apply path.
+     * @param expectedSessionId - blank Session captured before the Settings write.
+     * @param id - the effective default that the write persisted.
+     * @returns the Host refusal text, or undefined when applied or no longer relevant.
+     */
+    syncBlankSession(expectedSessionId: SessionSummary['id'], id: string): Promise<string | undefined>;
+    /** Acknowledge the introduction cue once the chip has played it. */
+    introduced(): void;
+    /** Acknowledge a displayed refusal without dismissing a newer attempt.
+     * @param refusal - the selection error whose Toast finished.
+     */
+    dismissRefusal(refusal: AgentPresetSeatState['error']): void;
+    /**
+     * Hand the staged choice to the current session, if there is one to take it.
+     *
+     * Called both by `select()` and by whoever observes the current session
+     * changing, because the session may appear either before or after the pick.
+     * @returns once the switch settled, or immediately when there is nothing to do.
+     */
+    apply(): Promise<void>;
+}
+//# sourceMappingURL=seat-store.d.ts.map

package/lib/types/client/section-store.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Agent-preset management controller: the roster as a list, a copy dialog as
+ * the only way a preset is created, and a read-only viewer over the shipped
+ * compositions.
+ *
+ * The browser edits no composition text. A new preset is a host-side copy of
+ * an existing one (`{ from, id, name? }` is all that crosses the wire), and
+ * everything after creation happens in the preset's own files — which is why
+ * the page's other job is getting the user TO those files: open the directory
+ * where the host has a desktop, show its path where it does not.
+ *
+ * The host stays the single fact source. Every mutation writes through the
+ * wire and the page re-reads the roster afterwards, because a copy changes
+ * more than the row it targeted.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import { type SnapshotStore } from '@qilin-agent/client-store';
+/** One preset row the page renders. */
+export interface PresetRow {
+    /** Preset id and directory name; the display name falls back to it. */
+    id: string;
+    /** Display name the preset published, absent when it published none. */
+    name?: string;
+    /** One sentence on what the preset is for. */
+    description?: string;
+    /** Whether the preset ships with the deployment or was authored locally. */
+    trust: 'system' | 'user';
+    /** Whether a session that names no preset gets this one. */
+    isDefault: boolean;
+    /**
+     * Why the preset cannot compose a session, absent when it can. A broken
+     * row renders marked and unselectable — its directory still occupies the
+     * id, so deleting it (or fixing the files) is the way out, and this page
+     * is where both of those live.
+     */
+    broken?: string;
+}
+/** The copy dialog: a new id and optional display name over a fixed source. */
+export interface CopyDraft {
+    /** The preset being copied. */
+    from: string;
+    /** Display name of the source, for the dialog title. */
+    fromTitle: string;
+    /** New preset id being typed; the directory name, so it is required. */
+    id: string;
+    /** Display name being typed; empty falls back to the id. */
+    name: string;
+    /** Whether the copy is in flight. */
+    saving: boolean;
+    /** The last copy failure, cleared by the next edit. */
+    error: string | null;
+}
+/** The read-only composition viewer over one shipped preset. */
+export interface PresetView {
+    /** The preset whose composition is shown. */
+    id: string;
+    /** Display name, for the dialog title. */
+    title: string;
+    /** Composition text exactly as stored. */
+    content: string;
+}
+/** Page snapshot. */
+export interface AgentPresetSectionState {
+    status: 'idle' | 'loading' | 'ready' | 'unavailable' | 'error';
+    /** Whole-load failure text; a copy failure stays on the dialog. */
+    error: string | null;
+    /** Whether the deployment configures a root new presets can be written to. */
+    authorable: boolean;
+    /** Whether the host can open a preset directory on a native desktop. */
+    hasDocument: boolean;
+    /** Whether new-session surfaces expose preset selection. */
+    showPicker: boolean;
+    /** Whether a mode-selection policy write is in flight. */
+    policySaving: boolean;
+    /** Every preset the deployment currently supplies. */
+    rows: readonly PresetRow[];
+    /** The open copy dialog, or null. */
+    copy: CopyDraft | null;
+    /** The open read-only viewer, or null. */
+    view: PresetView | null;
+    /** The preset awaiting delete confirmation. */
+    pendingDelete: string | null;
+    /** Whether a delete is in flight. */
+    deleting: boolean;
+    /**
+     * Preset directories shown as text because the host has no desktop opener
+     * — the answer `openDocument` gives instead of opening.
+     */
+    revealedPaths: Readonly<Record<string, string>>;
+}
+/**
+ * Why this copy cannot be submitted yet, as a locale key, or undefined when
+ * it can. Client-side only: the host re-checks the id and its answer is what
+ * the dialog reports on failure.
+ * @param draft - the open copy dialog.
+ * @param rows - the roster, for the collision check.
+ * @returns the blocking reason's locale key, or undefined when submittable.
+ */
+export declare function draftBlocker(draft: CopyDraft, rows: readonly PresetRow[]): 'idRequired' | 'idInvalid' | 'idTaken' | undefined;
+/** Reads the roster and drives the copy dialog, viewer, and location reveals. */
+export declare class AgentPresetSectionController {
+    private readonly ctx;
+    /**
+     * Called after this page changes the roster DIRECTORY, so the other
+     * surfaces reading the same roster re-read it. A settings field moving is
+     * already announced by the host through the forwarded
+     * `settings/document-updated`; a directory copied or deleted here is not,
+     * and the new-session chip has no other way to learn a preset it should
+     * offer now exists.
+     */
+    private readonly rosterChanged;
+    /** Page snapshot the renderer subscribes to. */
+    readonly store: SnapshotStore<AgentPresetSectionState>;
+    /** The one roster load whose completion current callers await. */
+    private loadFlight;
+    private reloadRequested;
+    constructor(ctx: ClientContext, 
+    /**
+     * Called after this page changes the roster DIRECTORY, so the other
+     * surfaces reading the same roster re-read it. A settings field moving is
+     * already announced by the host through the forwarded
+     * `settings/document-updated`; a directory copied or deleted here is not,
+     * and the new-session chip has no other way to learn a preset it should
+     * offer now exists.
+     */
+    rosterChanged?: () => void);
+    private set;
+    /** Read back and reflect the Host-effective default after a policy write. */
+    private confirmEffectiveDefault;
+    /**
+     * Show or hide new-session preset selection without changing the saved
+     * default. The Host roster resolves that saved default while selection is
+     * shown and the deployment default while it is hidden.
+     * @param showPicker - whether the new-session picker should be exposed.
+     * @param syncBlankSession - optional current-blank-task sync kept inside the saving state.
+     * @returns once the Host state and optional blank-task sync settle.
+     */
+    setPickerVisible(showPicker: boolean, syncBlankSession?: (id: string) => Promise<string | undefined>): Promise<void>;
+    private patchCopy;
+    /**
+     * Load the roster. An empty roster means the deployment composes no
+     * presets, which is a valid deployment rather than a failure — the section
+     * reports `unavailable` and renders nothing.
+     * @returns once the snapshot reflects the host.
+     */
+    load(): Promise<void>;
+    /** Coalesce invalidations without losing changes received during a read. */
+    private drainLoads;
+    /** Perform the section's one owned roster read. */
+    private loadOnce;
+    /**
+     * Open one shipped preset's composition in the read-only viewer.
+     * @param id - the preset to view.
+     * @returns once the composition loaded or the failure is on the page.
+     */
+    view(id: string): Promise<void>;
+    /** Close the read-only viewer. */
+    closeView(): void;
+    /**
+     * Open the copy dialog over one preset.
+     * @param from - the preset the copy will start from.
+     */
+    beginCopy(from: string): void;
+    /** Close the copy dialog, discarding whatever was typed. */
+    cancelCopy(): void;
+    /**
+     * Name the preset the copy creates.
+     * @param id - the id typed into the dialog.
+     */
+    setCopyId(id: string): void;
+    /**
+     * Name the copy's display name.
+     * @param name - the display name typed into the dialog.
+     */
+    setCopyName(name: string): void;
+    /**
+     * Submit the copy, re-read the roster, then take the user to the new
+     * preset's files — the directory opens where the host has a desktop, and
+     * its path appears on the new row where it does not.
+     * @returns once the copy settled and the page reflects it.
+     */
+    confirmCopy(): Promise<void>;
+    /**
+     * Open one preset's directory on the host desktop, or reveal its path on
+     * the row where the deployment has no opener to hand it to.
+     * @param id - the preset whose files the user wants.
+     * @returns once the host answered and the page reflects it.
+     */
+    openLocation(id: string): Promise<void>;
+    /**
+     * Ask for confirmation before deleting one preset.
+     * @param id - the preset to delete, or null to dismiss the confirmation.
+     */
+    confirmDelete(id: string | null): void;
+    /**
+     * Delete the preset awaiting confirmation, then re-read the roster.
+     *
+     * A session already composed from it keeps running: its composition was
+     * mounted at creation and nothing re-reads the file.
+     * @returns once the delete settled and the page reflects it.
+     */
+    remove(): Promise<void>;
+    /**
+     * Make one preset the default for sessions created later. Running sessions
+     * keep the composition they began with, so this never disturbs work.
+     * @param id - the preset to make default.
+     * @param syncBlankSession - optional current-blank-task sync kept inside the policy lock.
+     * @returns once the write and optional blank-task sync settle.
+     */
+    makeDefault(id: string, syncBlankSession?: (id: string) => Promise<string | undefined>): Promise<void>;
+}
+//# sourceMappingURL=section-store.d.ts.map