@acrylblends/blends-frame 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +105 -2
- package/cordis.patch.yml +3 -0
- package/lib/app-generation.d.ts +38 -0
- package/lib/app-generation.js +102 -0
- package/lib/app-generation.js.map +1 -0
- package/lib/app-plugins.d.ts +118 -0
- package/lib/app-reload.d.ts +73 -0
- package/lib/app-snapshot.d.ts +40 -0
- package/lib/app-urls.d.ts +17 -0
- package/lib/auto-save.d.ts +63 -0
- package/lib/branch-chats.d.ts +37 -0
- package/lib/client.js +18899 -0
- package/lib/client.js.map +1 -0
- package/lib/contract.d.ts +293 -0
- package/lib/git-sync.d.ts +52 -0
- package/lib/index.d.ts +169 -0
- package/lib/index.js +2923 -0
- package/lib/index.js.map +1 -0
- package/lib/outward-guard.d.ts +45 -0
- package/lib/real-chats.d.ts +42 -0
- package/lib/selection-context.d.ts +118 -0
- package/lib/tool-call-guard.d.ts +104 -0
- package/lib/types/client/BlendsFrame.d.ts +46 -0
- package/lib/types/client/FileView.d.ts +8 -0
- package/lib/types/client/FilesView.d.ts +17 -0
- package/lib/types/client/GitView.d.ts +18 -0
- package/lib/types/client/LeftPanel.d.ts +71 -0
- package/lib/types/client/PluginsSection.d.ts +7 -0
- package/lib/types/client/RemoteSync.d.ts +17 -0
- package/lib/types/client/RightPanel.d.ts +45 -0
- package/lib/types/client/SelectionChip.d.ts +59 -0
- package/lib/types/client/SettingsLauncher.d.ts +9 -0
- package/lib/types/client/ShortcutsRow.d.ts +15 -0
- package/lib/types/client/TerminalView.d.ts +7 -0
- package/lib/types/client/TurnSaveFooter.d.ts +18 -0
- package/lib/types/client/app-reload.d.ts +28 -0
- package/lib/types/client/branch-chats.d.ts +71 -0
- package/lib/types/client/branches.d.ts +23 -0
- package/lib/types/client/canvas/AppCanvas.d.ts +25 -0
- package/lib/types/client/canvas/app-canvas.d.ts +59 -0
- package/lib/types/client/canvas/picker.d.ts +27 -0
- package/lib/types/client/chat-draft.d.ts +15 -0
- package/lib/types/client/chat-saves.d.ts +28 -0
- package/lib/types/client/chats.d.ts +182 -0
- package/lib/types/client/feedback.d.ts +21 -0
- package/lib/types/client/frame-state.d.ts +34 -0
- package/lib/types/client/frame-view.d.ts +35 -0
- package/lib/types/client/fuzzy.d.ts +23 -0
- package/lib/types/client/git-sync.d.ts +39 -0
- package/lib/types/client/highlight.d.ts +15 -0
- package/lib/types/client/index.d.ts +23 -0
- package/lib/types/client/panel-resize.d.ts +29 -0
- package/lib/types/client/plugins-navigator.d.ts +51 -0
- package/lib/types/client/selection.d.ts +56 -0
- package/lib/types/client/sidebar-opens.d.ts +36 -0
- package/lib/types/client/snapshot.d.ts +11 -0
- package/lib/types/client/styles.d.ts +3 -0
- package/lib/types/client/switch-request.d.ts +18 -0
- package/lib/types/client/tab-sizing.d.ts +31 -0
- package/lib/types/client/tabs.d.ts +139 -0
- package/lib/types/client/tools.d.ts +15 -0
- package/lib/types/client/versions.d.ts +34 -0
- package/lib/types/client/view-state.d.ts +42 -0
- package/lib/types/contract.d.ts +293 -0
- package/package.json +122 -4
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The agent never sends the person's work out of the machine without their yes.
|
|
3
|
+
*
|
|
4
|
+
* Share and Push in the frame ask first (./app-plugins.ts, ./git-sync.ts); an agent with a shell could still run `git push`, `gh repo create` or
|
|
5
|
+
* `npm publish` itself, and the access mode may let the shell run unasked. This guard reads each shell call before it runs (`tools/pre-execute`)
|
|
6
|
+
* and turns one that pushes or publishes into DSH's own approval prompt (`ask`): the person sees the command and what it does, and it runs only
|
|
7
|
+
* when they allow it once. A policy that already refused the call stays refused. The app's `save_app` tool, which pushes when the app has a remote,
|
|
8
|
+
* asks the same way.
|
|
9
|
+
*
|
|
10
|
+
* It reads the command's words, so it is a seat belt for an honest agent, not a sandbox: a script that pushes from inside is not seen.
|
|
11
|
+
*/
|
|
12
|
+
/** What a shell command sends out of the machine (`git push`, `gh repo create`, `npm publish`), or undefined when it sends nothing. */
|
|
13
|
+
export declare function outwardAction(command: string): string | undefined;
|
|
14
|
+
/** The parts of a DSH tool call the guard reads. */
|
|
15
|
+
export interface OutwardExecution {
|
|
16
|
+
readonly name: string;
|
|
17
|
+
readonly arguments?: unknown;
|
|
18
|
+
}
|
|
19
|
+
/** DSH's pre-dispatch decision, the kinds this guard reads and returns. */
|
|
20
|
+
export type OutwardDecision = {
|
|
21
|
+
readonly kind: 'allow';
|
|
22
|
+
} | {
|
|
23
|
+
readonly kind: 'deny';
|
|
24
|
+
readonly reason: string;
|
|
25
|
+
} | {
|
|
26
|
+
readonly kind: 'cancel';
|
|
27
|
+
} | {
|
|
28
|
+
readonly kind: 'ask';
|
|
29
|
+
readonly reason: string;
|
|
30
|
+
readonly displayReason: {
|
|
31
|
+
readonly en: string;
|
|
32
|
+
};
|
|
33
|
+
};
|
|
34
|
+
export interface OutwardEvents {
|
|
35
|
+
on(name: 'tools/pre-execute', listener: (exec: OutwardExecution, next: () => Promise<OutwardDecision>) => Promise<OutwardDecision>): () => void;
|
|
36
|
+
}
|
|
37
|
+
/** The approval the person sees: what runs and why it asks. */
|
|
38
|
+
export declare function outwardQuestion(action: string, command: string | undefined): string;
|
|
39
|
+
/** What a call needs: the approval to ask, or undefined when it sends nothing out. */
|
|
40
|
+
export declare function outwardApproval(exec: OutwardExecution): {
|
|
41
|
+
readonly action: string;
|
|
42
|
+
readonly command?: string;
|
|
43
|
+
} | undefined;
|
|
44
|
+
/** Listen on DSH's pre-dispatch stage; returns the disposer. */
|
|
45
|
+
export declare function guardOutwardCommands(events: OutwardEvents, report: (line: string) => void): () => void;
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Which chats are real, and what each is called. A chat is real when it has at least one turn. DSH's session list marks a chat `blank` only while it is
|
|
3
|
+
* loaded and carries no title for one that is not, so the list alone cannot tell an old empty chat from a used one or name it; the Host reads each
|
|
4
|
+
* session's log once for both: a `turn/start`, and the title (DSH's own `session/title` event, else the person's first message, cut short).
|
|
5
|
+
* A chat with a title DSH or the person gave is final; one named from its first message is read again after a while, since DSH's title may follow.
|
|
6
|
+
*/
|
|
7
|
+
/** The longest a chat's name is in the left panel, in characters, before it is cut at a word. */
|
|
8
|
+
export declare const CHAT_TITLE_LIMIT = 32;
|
|
9
|
+
/** What the frame reads from a session log's events. */
|
|
10
|
+
export interface LogEvent {
|
|
11
|
+
readonly type: string;
|
|
12
|
+
readonly data?: unknown;
|
|
13
|
+
}
|
|
14
|
+
export interface ChatLook {
|
|
15
|
+
readonly hasTurn: boolean;
|
|
16
|
+
/** The chat's name; undefined when the log has neither a title nor a user message. */
|
|
17
|
+
readonly title: string | undefined;
|
|
18
|
+
/** True when DSH or the person named the chat (the title will not change by itself). */
|
|
19
|
+
readonly named: boolean;
|
|
20
|
+
}
|
|
21
|
+
export declare function lookAtLog(events: readonly LogEvent[]): ChatLook;
|
|
22
|
+
export interface RealChat {
|
|
23
|
+
readonly id: string;
|
|
24
|
+
readonly title: string;
|
|
25
|
+
}
|
|
26
|
+
export interface RealChatsDeps {
|
|
27
|
+
/** The ids of every session DSH knows. */
|
|
28
|
+
list(): Promise<readonly string[]>;
|
|
29
|
+
/** One read of the session's log. */
|
|
30
|
+
look(id: string): Promise<ChatLook>;
|
|
31
|
+
readonly report?: (cause: unknown) => void;
|
|
32
|
+
/** How long a chat named from its first message waits before it is read again, in milliseconds. */
|
|
33
|
+
readonly refreshMs?: number;
|
|
34
|
+
readonly now?: () => number;
|
|
35
|
+
}
|
|
36
|
+
export declare class RealChats {
|
|
37
|
+
private readonly deps;
|
|
38
|
+
private readonly known;
|
|
39
|
+
constructor(deps: RealChatsDeps);
|
|
40
|
+
/** The chats with a turn, in the order DSH lists them. A session that cannot be read is left out this time and asked again next time. */
|
|
41
|
+
read(): Promise<RealChat[]>;
|
|
42
|
+
}
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The element a chat message is about, delivered to the agent as a durable context message (docs/design/blends-frame-mockup.html, scenario 2).
|
|
3
|
+
*
|
|
4
|
+
* The composer's send gesture posts the pick to the Host out of band (./contract.ts, {@link FRAME_SELECTION_PATH}), keyed by session; the next
|
|
5
|
+
* `agent/pre-step` of that session takes it once and queues a user-role message whose source is not `user`, the way `dsh-time-context` and
|
|
6
|
+
* `dsh-session-reference` add theirs. The person's message keeps exactly their words: the chat renders the pick as its own small context row,
|
|
7
|
+
* named after the element, instead of carrying a block of text in the bubble.
|
|
8
|
+
*
|
|
9
|
+
* The pick belongs to the message that started the step. The send gesture posts before the message reaches the Host, so a pick stored after that
|
|
10
|
+
* message arrived cannot be its context; it is refused rather than attached to the next turn. A pick nobody claimed within {@link MAX_AGE_MS} is
|
|
11
|
+
* dropped for the same reason. A pick the Host never receives costs the context, never the message: the frame never touches the draft.
|
|
12
|
+
*/
|
|
13
|
+
import { type ContextFormed } from '@deepseek-ai/dsh-llm';
|
|
14
|
+
declare module '@deepseek-ai/dsh-llm' {
|
|
15
|
+
interface MessageSourceMap {
|
|
16
|
+
/** The element a message from the person is about; one producer, one form (see ./selection-context.ts). */
|
|
17
|
+
'acryl-selection': {
|
|
18
|
+
kind: 'acryl-selection';
|
|
19
|
+
} & ContextFormed;
|
|
20
|
+
}
|
|
21
|
+
}
|
|
22
|
+
/** One element picked in the app's canvas, as the message about it carries it. */
|
|
23
|
+
export interface SelectionContext {
|
|
24
|
+
/** The element's short name (`"Fix the invite link"`), the only part the chat's context row shows. */
|
|
25
|
+
readonly label: string;
|
|
26
|
+
/** The app page the canvas showed, with its query. */
|
|
27
|
+
readonly page: string;
|
|
28
|
+
/** A CSS selector that finds the element in that page. */
|
|
29
|
+
readonly selector: string;
|
|
30
|
+
}
|
|
31
|
+
export declare const SELECTION_LIMITS: {
|
|
32
|
+
/** The label is clipped by the picker; the Host only refuses what cannot be one. */
|
|
33
|
+
readonly label: 120;
|
|
34
|
+
readonly page: 500;
|
|
35
|
+
readonly selector: 500;
|
|
36
|
+
};
|
|
37
|
+
/** How long a pick waits for its step before it is dropped: a message is read within seconds of its send. */
|
|
38
|
+
export declare const MAX_AGE_MS = 120000;
|
|
39
|
+
/** One selection as the frame's client posted it; a string says what is wrong. */
|
|
40
|
+
export declare function parseSelectionContext(body: unknown): SelectionContext | string;
|
|
41
|
+
/** The session a posted selection belongs to, or undefined when the body names none. */
|
|
42
|
+
export declare function sessionOf(body: unknown): string | undefined;
|
|
43
|
+
/**
|
|
44
|
+
* What the agent reads: one line naming the element, its page and its selector, guarded as page data. The chat's context row is named by the
|
|
45
|
+
* source instead (the kind carries the label), so this line is what the expanded row shows and what the model gets.
|
|
46
|
+
*/
|
|
47
|
+
export declare function selectionModelText(selection: SelectionContext): string;
|
|
48
|
+
/**
|
|
49
|
+
* The durable source of the injected message: a stable producer kind, and a notice form whose one-line summary is what the chat's collapsed row
|
|
50
|
+
* shows ("Selected: <label>"). The page and selector stay in the model-facing content, which the row shows only when someone expands it.
|
|
51
|
+
*/
|
|
52
|
+
export declare function selectionSource(selection: SelectionContext): {
|
|
53
|
+
readonly kind: 'acryl-selection';
|
|
54
|
+
readonly form: 'notice';
|
|
55
|
+
readonly summary: string;
|
|
56
|
+
};
|
|
57
|
+
/** The picks waiting for their step, one per session, consumed once. */
|
|
58
|
+
export declare class SelectionInbox {
|
|
59
|
+
private readonly pending;
|
|
60
|
+
/** Record the pick a send gesture made; a newer pick of the same session replaces the older one. */
|
|
61
|
+
add(session: string, selection: SelectionContext, now?: number): void;
|
|
62
|
+
/**
|
|
63
|
+
* Take the pick that belongs to a message the session logged at `messageAt`.
|
|
64
|
+
* @param session - the chat's session id.
|
|
65
|
+
* @param messageAt - when the session's newest human message was logged.
|
|
66
|
+
* @param now - the host's clock.
|
|
67
|
+
* @returns the pick, once; undefined when there is none, it came after that message, or it waited too long.
|
|
68
|
+
*/
|
|
69
|
+
take(session: string, messageAt: number, now?: number): SelectionContext | undefined;
|
|
70
|
+
/** For tests and diagnostics: how many picks wait. */
|
|
71
|
+
get size(): number;
|
|
72
|
+
}
|
|
73
|
+
/** The part of one logged session event the frame reads: its type, when it happened, and its data. */
|
|
74
|
+
export interface SessionEventLike {
|
|
75
|
+
readonly type: string;
|
|
76
|
+
readonly time: number;
|
|
77
|
+
readonly data: unknown;
|
|
78
|
+
}
|
|
79
|
+
/** The part of a DSH session the frame reads: how far it has logged, and one event by its position. */
|
|
80
|
+
export interface SessionLike {
|
|
81
|
+
readonly id: string;
|
|
82
|
+
readonly seq: number;
|
|
83
|
+
eventAt(seq: number): SessionEventLike | undefined;
|
|
84
|
+
}
|
|
85
|
+
/**
|
|
86
|
+
* When the session's newest message from the person was logged.
|
|
87
|
+
* @param session - the chat's session.
|
|
88
|
+
* @param scan - how many of the newest events to read; a turn of tool calls can be long.
|
|
89
|
+
* @returns the event time, or undefined when the session has no human message yet.
|
|
90
|
+
*/
|
|
91
|
+
export declare function lastHumanMessageAt(session: SessionLike, scan?: number): number | undefined;
|
|
92
|
+
/** Whether and with which messages the loop enters a step. */
|
|
93
|
+
export type PreStepDecision = {
|
|
94
|
+
readonly kind: 'reject';
|
|
95
|
+
} | {
|
|
96
|
+
readonly kind: 'enter';
|
|
97
|
+
readonly messages: readonly unknown[];
|
|
98
|
+
};
|
|
99
|
+
/** The pre-step payload the frame reads: the agent (and so its session), the turn and the step. */
|
|
100
|
+
export interface PreStepPayload {
|
|
101
|
+
readonly agent: {
|
|
102
|
+
readonly session: SessionLike;
|
|
103
|
+
};
|
|
104
|
+
readonly turn: number;
|
|
105
|
+
readonly step: number;
|
|
106
|
+
}
|
|
107
|
+
/** `ctx.on('agent/pre-step', ...)`: DSH's agent-scoped waterfall before each model step. */
|
|
108
|
+
export interface PreStepEvents {
|
|
109
|
+
on(name: 'agent/pre-step', listener: (payload: PreStepPayload, next: () => Promise<PreStepDecision>) => Promise<PreStepDecision>): () => void;
|
|
110
|
+
}
|
|
111
|
+
/**
|
|
112
|
+
* Take a waiting pick at the step that reads the message it belongs to, and queue it as context.
|
|
113
|
+
* @param ctx - the frame's host context, whose events are DSH's.
|
|
114
|
+
* @param inbox - the picks posted by the frame's client.
|
|
115
|
+
* @param report - where a refused pick is logged.
|
|
116
|
+
* @returns the disposer of the listener.
|
|
117
|
+
*/
|
|
118
|
+
export declare function installSelectionContext(ctx: object, inbox: SelectionInbox, report: (cause: unknown) => void): () => void;
|
|
@@ -0,0 +1,104 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A tool call can never hold a builder's chat forever.
|
|
3
|
+
*
|
|
4
|
+
* DSH's agent loop awaits each stage of a tool call in turn, and its registry never abandons a stage's promise: a policy gate or a wrapper that does
|
|
5
|
+
* not settle leaves the turn running with no process and no prompt, past the command's own timeout (which only arms inside the execute stage), and
|
|
6
|
+
* the Stop button cannot end it either. This guard sits outside each stage and gives it a limit:
|
|
7
|
+
*
|
|
8
|
+
* - Before the tool runs (`tools/pre-execute`, every tool): over the limit, or on Stop, the call is refused without running. An approval is asked
|
|
9
|
+
* after this stage, so a person deciding is not counted.
|
|
10
|
+
* - While a command runs (`tools/execute`, the shell tools): its own timeout plus a grace. A command past its timeout returns by itself (DSH keeps it
|
|
11
|
+
* as a job), so reaching this limit means the call is stuck. The command is asked to stop, then the call ends with a sentence that says what happened.
|
|
12
|
+
* Stop is given the same short wait. While a person has a prompt open in that chat the limit waits for them.
|
|
13
|
+
* - After the tool ran (`tools/post-execute`, every tool): over the limit, the result is kept as it is.
|
|
14
|
+
*
|
|
15
|
+
* Each firing is reported with the stage and the tool, which is what the next stall needs for its root cause.
|
|
16
|
+
*
|
|
17
|
+
* One more thing can end a chat for good: an agent stopping the app's Host, which is the process running it and the frame. A shell command that kills
|
|
18
|
+
* that process (by its id, its port or its script) is refused with what to do instead. It is a seat belt for an honest mistake, not a sandbox.
|
|
19
|
+
*/
|
|
20
|
+
export declare const PREPARE_LIMIT_MS = 120000;
|
|
21
|
+
export declare const FINISH_LIMIT_MS = 60000;
|
|
22
|
+
/** Past a command's timeout: what its kill escalation, its output and the session's flush may take before the call counts as stuck. */
|
|
23
|
+
export declare const COMMAND_GRACE_MS = 60000;
|
|
24
|
+
/** How long a command that was told to stop may take to return. */
|
|
25
|
+
export declare const STOP_WAIT_MS = 5000;
|
|
26
|
+
export declare const TOOL_CALL_STALLED = "TOOL_CALL_STALLED";
|
|
27
|
+
/** The parts of a DSH tool execution the guard reads; `signal` it replaces for the stage, as DSH's own timeout policy does. */
|
|
28
|
+
export interface GuardedExecution {
|
|
29
|
+
readonly name: string;
|
|
30
|
+
readonly arguments?: unknown;
|
|
31
|
+
readonly agent?: {
|
|
32
|
+
readonly session: {
|
|
33
|
+
readonly id: string;
|
|
34
|
+
};
|
|
35
|
+
};
|
|
36
|
+
signal: AbortSignal;
|
|
37
|
+
}
|
|
38
|
+
/** The stalled call's result, in the shape DSH's timeout policy uses. */
|
|
39
|
+
export interface StalledResult {
|
|
40
|
+
readonly content: readonly [{
|
|
41
|
+
readonly type: 'text';
|
|
42
|
+
readonly text: string;
|
|
43
|
+
}];
|
|
44
|
+
readonly isError: true;
|
|
45
|
+
readonly error: {
|
|
46
|
+
readonly message: string;
|
|
47
|
+
readonly info: {
|
|
48
|
+
readonly name: string;
|
|
49
|
+
readonly code: string;
|
|
50
|
+
};
|
|
51
|
+
};
|
|
52
|
+
}
|
|
53
|
+
type Decision = {
|
|
54
|
+
readonly kind: 'deny';
|
|
55
|
+
readonly reason: string;
|
|
56
|
+
} | {
|
|
57
|
+
readonly kind: 'cancel';
|
|
58
|
+
} | {
|
|
59
|
+
readonly kind: 'accept';
|
|
60
|
+
} | object;
|
|
61
|
+
/** The DSH events the guard listens on; each `on` returns its disposer. */
|
|
62
|
+
export interface ToolCallEvents {
|
|
63
|
+
on(name: 'tools/pre-execute', listener: (exec: GuardedExecution, next: () => Promise<Decision>) => Promise<Decision>, options: {
|
|
64
|
+
prepend: true;
|
|
65
|
+
}): () => void;
|
|
66
|
+
on(name: 'tools/execute', listener: (exec: GuardedExecution, next: () => Promise<object>) => Promise<object>, options: {
|
|
67
|
+
prepend: true;
|
|
68
|
+
}): () => void;
|
|
69
|
+
on(name: 'tools/post-execute', listener: (exec: GuardedExecution, result: unknown, next: () => Promise<Decision>) => Promise<Decision>, options: {
|
|
70
|
+
prepend: true;
|
|
71
|
+
}): () => void;
|
|
72
|
+
on(name: 'session/event', listener: (session: {
|
|
73
|
+
readonly id: string;
|
|
74
|
+
}, event: {
|
|
75
|
+
readonly type: string;
|
|
76
|
+
readonly data: unknown;
|
|
77
|
+
}) => void): () => void;
|
|
78
|
+
}
|
|
79
|
+
/** The limit of a shell call's execute stage; undefined for any other tool, whose run has no length to hold it to. */
|
|
80
|
+
export declare function commandLimitMs(exec: Pick<GuardedExecution, 'name' | 'arguments'>): number | undefined;
|
|
81
|
+
export declare function stalledResult(toolName: string, why: 'stuck' | 'stopped', limitMs: number): StalledResult;
|
|
82
|
+
/** The Host this guard runs in, as a shell command would name it. */
|
|
83
|
+
export interface HostIdentity {
|
|
84
|
+
readonly hostPid: number;
|
|
85
|
+
readonly hostPort?: number;
|
|
86
|
+
/** The Host's process group: `kill 0`, `kill -- -<id>` or `pkill -g <id>` ends it too. */
|
|
87
|
+
readonly hostGroupId?: number;
|
|
88
|
+
/** The Host's own command line (`process.execPath` and its arguments), for `pkill -f` patterns. */
|
|
89
|
+
readonly hostCommand?: string;
|
|
90
|
+
/** The Host's process name, for `pkill`/`killall` without `-f`. */
|
|
91
|
+
readonly hostName?: string;
|
|
92
|
+
}
|
|
93
|
+
/** Whether a shell call would stop the Host. A kill alone is fine: agents stop their own test servers. */
|
|
94
|
+
export declare function stopsHost(exec: Pick<GuardedExecution, 'name' | 'arguments'>, host: HostIdentity): boolean;
|
|
95
|
+
export declare const HOST_REFUSAL = "that command could stop the app's Host, the process running this chat and the page beside it: it names the Host, its process group, all node processes, or a pattern that matches it. It was not run. To restart only a process you started, stop that process by its own id (kill <pid>) and start it again; never a group, a name like node, or a broad -f pattern. A saved change in src/ or plugins/ reloads the app by itself; if a change does not show, the reload failed, so read the error and fix it.";
|
|
96
|
+
/**
|
|
97
|
+
* Put the guard on the tool calls of every chat.
|
|
98
|
+
* @param events - the plugin's context, as the events it listens on.
|
|
99
|
+
* @param report - hears each firing.
|
|
100
|
+
* @param host - the Host to protect from a shell command; left out, nothing is refused.
|
|
101
|
+
* @returns the disposer: the listeners and every running limit stop.
|
|
102
|
+
*/
|
|
103
|
+
export declare function guardToolCalls(events: ToolCallEvents, report: (line: string) => void, host?: HostIdentity): () => void;
|
|
104
|
+
export {};
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The Blends frame (docs/design/blends-frame-mockup.html): a top bar; on the left the branches with what is open on them, and the versions; the
|
|
3
|
+
* app alone in the centre; on the right the agents as tabs. Nothing of the IDE's workbench is here - no projects, tab strip of tiles, dock or start
|
|
4
|
+
* page. DSH renders only inside it: the chat is the keyed `main` entry `conversation` in the right panel, and a keyed panel DSH opens (Settings)
|
|
5
|
+
* covers the frame as a dialog.
|
|
6
|
+
*/
|
|
7
|
+
import type { PropsRenderSlots, PropsRuntime } from '@acrylblends/ui/frame';
|
|
8
|
+
import type { DesktopLayoutState } from '@acrylblends/app-shell/client';
|
|
9
|
+
import type { AppCanvasState } from './canvas/app-canvas.ts';
|
|
10
|
+
import type { AppReloadStore } from './app-reload.ts';
|
|
11
|
+
import type { FrameStateStore } from './frame-state.ts';
|
|
12
|
+
import type { SelectionStore } from './selection.ts';
|
|
13
|
+
import type { FrameViewState } from './view-state.ts';
|
|
14
|
+
import { type BranchesPort, type ChatsPort, type FeedbackPort } from './LeftPanel.tsx';
|
|
15
|
+
import type { BranchChatsPort } from './branch-chats.ts';
|
|
16
|
+
import { type VersionsPort } from './versions.ts';
|
|
17
|
+
import type { GitSyncPort } from './git-sync.ts';
|
|
18
|
+
import { type SidebarPort } from './RightPanel.tsx';
|
|
19
|
+
import type { FrameTabs } from './tabs.ts';
|
|
20
|
+
import type { SwitchRequests } from './switch-request.ts';
|
|
21
|
+
import type { FrameTools } from './tools.ts';
|
|
22
|
+
export interface BlendsFrameInjected {
|
|
23
|
+
readonly layout: DesktopLayoutState;
|
|
24
|
+
/** DSH's right sidebar, drawn in the right panel's Panel tab. */
|
|
25
|
+
readonly sidebar: SidebarPort;
|
|
26
|
+
readonly canvas: AppCanvasState;
|
|
27
|
+
readonly selection: SelectionStore;
|
|
28
|
+
readonly frameState: FrameStateStore;
|
|
29
|
+
/** Whether the app's last code was refused (a syntax error): the bar says so while the canvas keeps the last good app. */
|
|
30
|
+
readonly appReload: AppReloadStore;
|
|
31
|
+
readonly view: FrameViewState;
|
|
32
|
+
readonly chats: ChatsPort;
|
|
33
|
+
readonly versions: VersionsPort;
|
|
34
|
+
/** The Git tab's push and pull (the Host runs git). */
|
|
35
|
+
readonly gitSync: GitSyncPort;
|
|
36
|
+
readonly tabs: FrameTabs;
|
|
37
|
+
readonly tools: FrameTools;
|
|
38
|
+
readonly feedback: FeedbackPort;
|
|
39
|
+
readonly branches: BranchesPort;
|
|
40
|
+
/** Which branch each chat was opened on (DSH keeps no branches; the Host records it). */
|
|
41
|
+
readonly branchChats: BranchChatsPort;
|
|
42
|
+
/** A chat of another branch asked for from the chat's History: the left panel offers the switch. */
|
|
43
|
+
readonly switchRequests: SwitchRequests;
|
|
44
|
+
}
|
|
45
|
+
export type BlendsFrameProps = PropsRuntime<'root'> & PropsRenderSlots<'main' | 'rightbar' | 'shell.overlay' | 'sidebar.settings'> & BlendsFrameInjected;
|
|
46
|
+
export declare function BlendsFrame({ layout, sidebar, canvas, selection, frameState, appReload, view, chats, versions, gitSync, tabs, tools, feedback, branches, branchChats, switchRequests, renderSlot }: BlendsFrameProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
/** A file tab: the file as text, with line numbers and syntax colours. Read when the tab is shown. */
|
|
2
|
+
import type { WorkspaceFilesApi } from '@acrylblends/workspace/ui';
|
|
3
|
+
export interface FileViewProps {
|
|
4
|
+
readonly files: WorkspaceFilesApi;
|
|
5
|
+
readonly root: string;
|
|
6
|
+
readonly path: string;
|
|
7
|
+
}
|
|
8
|
+
export declare function FileView({ files, root, path }: FileViewProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The Files tab: a fuzzy search over every file of the app (⌘P anywhere), then the folder tree. A file opens as its own tab. Ignored files (build
|
|
3
|
+
* output, dependencies) are left out of both, as in the mockup.
|
|
4
|
+
*/
|
|
5
|
+
import type { WorkspaceFilesApi } from '@acrylblends/workspace/ui';
|
|
6
|
+
/** The window event ⌘P sends: the Files tab is shown and its search takes the keys. */
|
|
7
|
+
export declare const FILES_SEARCH_EVENT = "acryl-blends:files-search";
|
|
8
|
+
export interface FilesViewProps {
|
|
9
|
+
readonly files: WorkspaceFilesApi;
|
|
10
|
+
readonly root: string;
|
|
11
|
+
/** The file open as a tab, if any: its folders are expanded and its row marked. */
|
|
12
|
+
readonly current?: string | undefined;
|
|
13
|
+
readonly openFile: (path: string) => void;
|
|
14
|
+
}
|
|
15
|
+
/** The folders above a file, outermost first: `src/a/b.ts` gives `src`, `src/a`. */
|
|
16
|
+
export declare function foldersAbove(path: string): string[];
|
|
17
|
+
export declare function FilesView({ files, root, current, openFile }: FilesViewProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The Git tab: the branch against its remote with Push and Pull, what changed since the newest version, then the versions as history. Read
|
|
3
|
+
* again whenever the frame sees a new head or count; the remote is asked (a fetch) when the tab opens and by each push or pull.
|
|
4
|
+
*/
|
|
5
|
+
import type { WorkspaceGitApi } from '@acrylblends/workspace/ui';
|
|
6
|
+
import type { GitSyncPort } from './git-sync.ts';
|
|
7
|
+
import { type VersionsPort } from './versions.ts';
|
|
8
|
+
export interface GitViewProps {
|
|
9
|
+
readonly git: WorkspaceGitApi;
|
|
10
|
+
readonly versions: VersionsPort;
|
|
11
|
+
readonly sync: GitSyncPort;
|
|
12
|
+
readonly root: string;
|
|
13
|
+
/** Changes when the worktree does (the frame state's head and unsaved count): the tab reads again. */
|
|
14
|
+
readonly revision: string;
|
|
15
|
+
}
|
|
16
|
+
/** The letter a change shows: git's own, with an untracked file as U (new), as editors show it. */
|
|
17
|
+
export declare const changeLetter: (code: string) => string;
|
|
18
|
+
export declare function GitView({ git, versions, sync, root, revision }: GitViewProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
/** The left panel: the app's branches, each with what is open on it, then the versions of the checked-out branch, and where the app runs. */
|
|
2
|
+
import { type FeedbackNoteView, type FrameState } from '../contract.ts';
|
|
3
|
+
import { type FrameTabs } from './tabs.ts';
|
|
4
|
+
import { type VersionsPort } from './versions.ts';
|
|
5
|
+
import { type BranchesApi } from './branches.ts';
|
|
6
|
+
import type { BranchChatsPort } from './branch-chats.ts';
|
|
7
|
+
import type { SwitchRequests } from './switch-request.ts';
|
|
8
|
+
import type { GitSyncPort } from './git-sync.ts';
|
|
9
|
+
import { type FeedbackApi } from './feedback.ts';
|
|
10
|
+
/** A chat on the branch, as the left panel lists it. */
|
|
11
|
+
export interface ChatRow {
|
|
12
|
+
readonly id: string;
|
|
13
|
+
readonly title: string;
|
|
14
|
+
readonly current: boolean;
|
|
15
|
+
/** When the chat last changed (ms since the epoch); absent when DSH did not say. */
|
|
16
|
+
readonly updatedAt?: number;
|
|
17
|
+
}
|
|
18
|
+
/** The chats the frame knows (DSH's sessions), and opening one in the right panel. */
|
|
19
|
+
export interface ChatsPort {
|
|
20
|
+
getSnapshot(): readonly ChatRow[];
|
|
21
|
+
subscribe(listener: () => void): () => void;
|
|
22
|
+
open(id: string): void;
|
|
23
|
+
/** A new chat on the checked-out branch, shown at once; undefined without DSH's sessions service. */
|
|
24
|
+
create(): Promise<string | undefined>;
|
|
25
|
+
/** "+ then Chat": a chat of its own on the checked-out branch (the one on screen is reused while it has no turn). */
|
|
26
|
+
startChat(): Promise<{
|
|
27
|
+
readonly id: string;
|
|
28
|
+
readonly made: boolean;
|
|
29
|
+
} | undefined>;
|
|
30
|
+
/** Show the checked-out branch's chat for the base tab: its newest open chat that has no tab of its own, else a new one. */
|
|
31
|
+
openPrimary(exclude: ReadonlySet<string>): void;
|
|
32
|
+
/** Open a chat of the checked-out branch from History: a closed chat becomes open, as a tab of its own, and is shown. */
|
|
33
|
+
show(id: string): void;
|
|
34
|
+
/** Close a chat (its tab's x); when it is on screen the view moves to `prefer`, else to the base tab's chat, else to a new chat. */
|
|
35
|
+
closeChat(id: string, tabbed: ReadonlySet<string>, prefer?: string): void;
|
|
36
|
+
}
|
|
37
|
+
/** Feedback from users: the notes, and handing one to an agent (the chat's composer). */
|
|
38
|
+
export interface FeedbackPort {
|
|
39
|
+
readonly api: FeedbackApi;
|
|
40
|
+
/** @returns false when there is no chat to hand it to. */
|
|
41
|
+
hand(note: FeedbackNoteView): Promise<boolean>;
|
|
42
|
+
}
|
|
43
|
+
/** The left panel's branch calls: New, and moving to an existing branch with the state re-read and the app page reloaded. */
|
|
44
|
+
export interface BranchesPort {
|
|
45
|
+
readonly api: BranchesApi;
|
|
46
|
+
readonly changed: () => Promise<void>;
|
|
47
|
+
/** Switch the app's folder to a branch, read the frame state again and reload the app page; rejects with the Host's reason. */
|
|
48
|
+
readonly switchTo: (name: string) => Promise<void>;
|
|
49
|
+
}
|
|
50
|
+
export interface LeftPanelProps {
|
|
51
|
+
readonly state: FrameState;
|
|
52
|
+
/** Read the frame state now (the unsaved count may have changed since the last poll); undefined when the Host could not be read. */
|
|
53
|
+
readonly readState: () => Promise<FrameState | undefined>;
|
|
54
|
+
readonly chats: ChatsPort;
|
|
55
|
+
readonly versions: VersionsPort;
|
|
56
|
+
/** The right panel's tabs: the branch lists its open agents and terminals, and a click shows one. */
|
|
57
|
+
readonly tabs: FrameTabs;
|
|
58
|
+
readonly feedback: FeedbackPort;
|
|
59
|
+
readonly branches: BranchesPort;
|
|
60
|
+
/** Which branch each chat was opened on (DSH keeps none; the Host records it). */
|
|
61
|
+
readonly branchChats: BranchChatsPort;
|
|
62
|
+
/** A chat of another branch asked for from the chat's History: the switch is offered here, with the same guard as a click on the panel's own rows. */
|
|
63
|
+
readonly switchRequests: SwitchRequests;
|
|
64
|
+
/** Show a right panel tab (opening the panel when it is closed). */
|
|
65
|
+
readonly showTab: (id: string) => void;
|
|
66
|
+
/** Told the newest version's label ("v7"), for the top bar. */
|
|
67
|
+
readonly onVersionLabel: (label: string | undefined) => void;
|
|
68
|
+
/** The branch's remote: the versions header's ↑/↓ chips send the versions there and bring its new ones in (the Git tab's Push and Pull). */
|
|
69
|
+
readonly gitSync: GitSyncPort;
|
|
70
|
+
}
|
|
71
|
+
export declare function LeftPanel({ state, readState, chats, versions, tabs, feedback, branches, branchChats, switchRequests, showTab, onVersionLabel, gitSync }: LeftPanelProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
/** The Plugins page of Settings: search, the groups as chips, and one row per plugin with who made it, its state and its switch. */
|
|
2
|
+
import { type NavigatorPlugin } from './plugins-navigator.ts';
|
|
3
|
+
export interface PluginsSectionInjected {
|
|
4
|
+
/** Every plugin of the app and the frame, read fresh. */
|
|
5
|
+
readonly loadPlugins: () => Promise<readonly NavigatorPlugin[]>;
|
|
6
|
+
}
|
|
7
|
+
export declare function PluginsSection({ loadPlugins }: PluginsSectionInjected): import("react").JSX.Element;
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The branch against its remote, with Pull and Push and the line the last one said. Two faces on one hook: the Git tab's remote row, and the
|
|
3
|
+
* compact chips on the left panel's versions header (`↑2` / `↓1` / `✓`, with the line as a brief toast). Read again whenever `revision` changes;
|
|
4
|
+
* the first read asks the remote (a fetch), later ones read the local refs, and each push or pull asks it anyway. A push sends the person's
|
|
5
|
+
* versions under their name, so Push first asks what it will send and where ("Push 2 versions to origin/main (github.com/ana/notes)?"), with
|
|
6
|
+
* Cancel as the default, and sends only that.
|
|
7
|
+
*/
|
|
8
|
+
import { type GitSyncPort } from './git-sync.ts';
|
|
9
|
+
export interface RemoteSyncProps {
|
|
10
|
+
readonly sync: GitSyncPort;
|
|
11
|
+
readonly root: string;
|
|
12
|
+
readonly revision: string;
|
|
13
|
+
}
|
|
14
|
+
/** The Git tab's row. */
|
|
15
|
+
export declare function RemoteSync({ sync, root, revision }: RemoteSyncProps): import("react").JSX.Element;
|
|
16
|
+
/** The versions header's chips; nothing when the branch has no remote. */
|
|
17
|
+
export declare function RemoteChips({ sync, root, revision }: RemoteSyncProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The right panel (docs/design/blends-frame-mockup.html): everything the person works with, as tabs opened with +. Agents: the chat (DSH's
|
|
3
|
+
* conversation with the model the person connected) and Claude Code, Codex or Pi as they are, TUIs in a PTY. Tools: a terminal, Files (fuzzy
|
|
4
|
+
* search, a file opens as its own tab) and Git. There is no Browser: the canvas is the browser. The chat has History at its top left.
|
|
5
|
+
*/
|
|
6
|
+
import { type ReactNode } from 'react';
|
|
7
|
+
import type { FrameState } from '../contract.ts';
|
|
8
|
+
import type { ChatsPort } from './LeftPanel.tsx';
|
|
9
|
+
import { type BranchChatsPort } from './branch-chats.ts';
|
|
10
|
+
import type { SwitchRequests } from './switch-request.ts';
|
|
11
|
+
import { type FrameTabs } from './tabs.ts';
|
|
12
|
+
import type { FrameTools } from './tools.ts';
|
|
13
|
+
import { type VersionsPort } from './versions.ts';
|
|
14
|
+
import type { GitSyncPort } from './git-sync.ts';
|
|
15
|
+
export interface RightPanelProps {
|
|
16
|
+
readonly chats: ChatsPort;
|
|
17
|
+
readonly tabs: FrameTabs;
|
|
18
|
+
readonly tools: FrameTools;
|
|
19
|
+
readonly versions: VersionsPort;
|
|
20
|
+
readonly gitSync: GitSyncPort;
|
|
21
|
+
readonly state: FrameState | undefined;
|
|
22
|
+
/** Which branch each chat was opened on, for the history's rows. */
|
|
23
|
+
readonly branchChats: BranchChatsPort;
|
|
24
|
+
/** Where a chat of another branch is asked for: the left panel offers the switch first. */
|
|
25
|
+
readonly switchRequests: SwitchRequests;
|
|
26
|
+
readonly renderConversation: () => ReactNode;
|
|
27
|
+
/** DSH's right sidebar (the `rightbar` slot) at the given width. Always mounted, so DSH's panel is there to open; shown only on its tab. */
|
|
28
|
+
readonly renderDetails: (width: number) => ReactNode;
|
|
29
|
+
/** Whether DSH's right sidebar is open, as it reports through the layout; it opens and closes its tab here. */
|
|
30
|
+
readonly details: {
|
|
31
|
+
subscribe(listener: () => void): () => void;
|
|
32
|
+
getSnapshot(): boolean;
|
|
33
|
+
};
|
|
34
|
+
readonly sidebar: SidebarPort;
|
|
35
|
+
}
|
|
36
|
+
/** DSH's right sidebar as the Panel tab drives it. */
|
|
37
|
+
export interface SidebarPort {
|
|
38
|
+
/** Collapse it (DSH's own collapse), when the person closes its tab. */
|
|
39
|
+
close(): void;
|
|
40
|
+
/** Expand it (DSH's own expand), when the person picks its tab. */
|
|
41
|
+
expand(): void;
|
|
42
|
+
/** Hear each page opened in it. @returns the disposer. */
|
|
43
|
+
onOpened(listener: () => void): () => void;
|
|
44
|
+
}
|
|
45
|
+
export declare function RightPanel({ chats, tabs, tools, versions, gitSync, state, branchChats, switchRequests, renderConversation, renderDetails, details, sidebar }: RightPanelProps): import("react").JSX.Element;
|
|
@@ -0,0 +1,59 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The chip inside the chat composer for the element picked in the app (docs/design/blends-frame-mockup.html, scenario 2): "Selected: ..." at the
|
|
3
|
+
* left of the input row, the person's placeholder after it. DSH has no slot on the input row itself, so the chip rides its `conversation.input.overlay`
|
|
4
|
+
* seat inside the composer card, and the frame moves the editor and its placeholder right by the chip's width while the pick is there. The context
|
|
5
|
+
* reaches the agent on the next message through the send hook, which writes the element's page and selector into the draft at the moment the
|
|
6
|
+
* composer sends, so the person's own text stays exactly as they typed it.
|
|
7
|
+
*/
|
|
8
|
+
import type { SelectedElement } from './selection.ts';
|
|
9
|
+
export interface SelectionChipInjected {
|
|
10
|
+
readonly selection: {
|
|
11
|
+
get(): SelectedElement | undefined;
|
|
12
|
+
subscribe(listener: () => void): () => void;
|
|
13
|
+
};
|
|
14
|
+
clear(): void;
|
|
15
|
+
/** Hand the pick to the frame's Host just before the person's own send; the message itself is sent untouched. */
|
|
16
|
+
send(): void;
|
|
17
|
+
/** Return the keyboard to the composer, the way the frame's feedback hand-off does. */
|
|
18
|
+
focus(): void;
|
|
19
|
+
}
|
|
20
|
+
export type SelectionChipProps = SelectionChipInjected;
|
|
21
|
+
/** The mockup's gap between the chip and the input text. */
|
|
22
|
+
export declare const CHIP_GAP = 8;
|
|
23
|
+
/** The custom property the editor carries while a chip is shown: the first line's indent (./styles.ts reads it). */
|
|
24
|
+
export declare const CHIP_INSET_PROPERTY = "--acrylBlendsChipInset";
|
|
25
|
+
/** Where the chip sits inside the composer card, and how far the draft's text moves right to make room for it. */
|
|
26
|
+
export interface ChipGeometry {
|
|
27
|
+
/** The chip's left, in the overlay anchor's coordinates. */
|
|
28
|
+
readonly left: number;
|
|
29
|
+
/** The chip's top, in the overlay anchor's coordinates. */
|
|
30
|
+
readonly top: number;
|
|
31
|
+
/** The editor's and placeholder's left inset while the chip is shown. */
|
|
32
|
+
readonly textInset: number;
|
|
33
|
+
}
|
|
34
|
+
/**
|
|
35
|
+
* The chip's box and the draft's inset for one layout.
|
|
36
|
+
* @param editor - the contenteditable's box, in viewport coordinates.
|
|
37
|
+
* @param anchor - the composer's overlay anchor (the chip's containing block), in viewport coordinates.
|
|
38
|
+
* @param chip - the chip's size.
|
|
39
|
+
* @param lineHeight - the editor's line height.
|
|
40
|
+
* @param paddingLeft - the editor's left pad before the chip.
|
|
41
|
+
* @param paddingTop - the editor's top pad before the chip.
|
|
42
|
+
* @returns the chip's position and the draft's new left inset; the chip is vertically centered on the first line.
|
|
43
|
+
*/
|
|
44
|
+
export declare function chipGeometry(editor: {
|
|
45
|
+
readonly left: number;
|
|
46
|
+
readonly top: number;
|
|
47
|
+
}, anchor: {
|
|
48
|
+
readonly left: number;
|
|
49
|
+
readonly top: number;
|
|
50
|
+
}, chip: {
|
|
51
|
+
readonly width: number;
|
|
52
|
+
readonly height: number;
|
|
53
|
+
}, lineHeight: number, paddingLeft: number, paddingTop: number): ChipGeometry;
|
|
54
|
+
/**
|
|
55
|
+
* Whether one DOM event is a send gesture of the chat composer. Only the composer card counts, so the rest of the page keeps its own keys
|
|
56
|
+
* and clicks; an open trigger menu owns Enter because the person is picking a reference or a command, not sending.
|
|
57
|
+
*/
|
|
58
|
+
export declare function isSendGesture(event: Event): boolean;
|
|
59
|
+
export declare function SelectionChip({ selection, clear, send, focus }: SelectionChipProps): import("react").JSX.Element | null;
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The top bar's gear. DSH's Settings (`dsh-client-ui-settings-general`) is a modal that renders inside its own `sidebar.settings` slot, opened by
|
|
3
|
+
* whatever fills that slot's `settings.launcher`; the frame renders the slot in its top bar and fills the launcher with this gear, so the gear opens
|
|
4
|
+
* DSH's real Settings and nothing else. The Desktop's Settings... menu item reaches the same launcher through a window event.
|
|
5
|
+
*/
|
|
6
|
+
import type { PropsRuntime } from '@acrylblends/ui/frame';
|
|
7
|
+
/** The window event the Desktop's Settings... menu item sends (`plugins/desktop/frame.ts`, `openFrameSettings`); keep the string in step. */
|
|
8
|
+
export declare const OPEN_SETTINGS_EVENT = "acryl:open-settings";
|
|
9
|
+
export declare function SettingsLauncher({ settingsOpen, openSettings, settingsShortcut }: PropsRuntime<'settings.launcher'>): import("react").JSX.Element;
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Settings > General's short list of shortcuts (docs/design/blends-frame-mockup.html: "General, with a short list of shortcuts"): the keys that are
|
|
3
|
+
* set, read from DSH's shortcut service, and the frame's own Find a file. Changing a key is DSH's "Edit shortcuts" dialog; the IDE's full Shortcuts
|
|
4
|
+
* section is not part of the frame.
|
|
5
|
+
*/
|
|
6
|
+
import type { ShortcutCatalogEntry, Shortcuts } from '@acrylblends/ui/frame';
|
|
7
|
+
export interface ShortcutsRowInjected {
|
|
8
|
+
readonly shortcuts: Shortcuts;
|
|
9
|
+
}
|
|
10
|
+
export declare function shortcutList(catalog: readonly ShortcutCatalogEntry[]): {
|
|
11
|
+
readonly id: string;
|
|
12
|
+
readonly label: string;
|
|
13
|
+
readonly keys: readonly string[];
|
|
14
|
+
}[];
|
|
15
|
+
export declare function ShortcutsRow({ shortcuts }: ShortcutsRowInjected): import("react").JSX.Element;
|