mulmoterminal 6.3.0 → 6.4.0

package/common/keymap.ts

@@ -7,7 +7,7 @@
 // The server sanitizes and persists it; the browser matches keydowns against it. One
 // definition here so the accepted syntax can't drift between the two.
 //
-//   "keymap": { "zoom-next": "PageDown", "zoom-prev": "Shift+PageUp" }
+//   "keymap": { "zoom-next": "PageDown", "zoom-prev": "Shift+PageUp", "files-find": "Cmd+K p" }
 
 // Actions a key can be bound to. Adding one here is all it takes for the config to accept it.
 import { isRecord } from "./isRecord.js";
@@ -26,6 +26,7 @@ export const KEYMAP_ACTIONS = [
   "terminal-restart",
   "files-find",
   "files-search",
+  "command-palette",
   "copy",
   "paste",
 ] as const;
@@ -128,6 +129,9 @@ export function parseKeyBinding(input: string): KeyBinding | null {
   if (parts.length === 0 || parts.some((part) => part === "")) return null;
   const key = parts[parts.length - 1];
   if (key === undefined) return null; // unreachable: parts.length was checked above
+  // No browser reports a key with whitespace in it, so `"Cmd+K p"` read as ONE keystroke named
+  // "K p" was accepted and never fired. A sequence is spelled with a space; see parseKeySequence.
+  if (/\s/.test(key)) return null;
   const binding: KeyBinding = { key, shift: false, alt: false, ctrl: false, meta: false };
   for (const part of parts.slice(0, -1)) {
     const flag = MODIFIERS[part.toLowerCase()];
@@ -138,6 +142,47 @@ export function parseKeyBinding(input: string): KeyBinding | null {
   return MODIFIERS[key.toLowerCase()] ? null : binding;
 }
 
+// The most keystrokes one binding can be. Two is a prefix and a key after it, as in tmux or Emacs's
+// `C-x b` — enough to put many actions behind one key the browser lets through (#2265).
+export const MAX_SEQUENCE_STROKES = 2;
+
+// Parse `"Cmd+K p"` into its keystrokes, or null when it is malformed. Strokes are separated by
+// whitespace, which no single keystroke can contain. A single keystroke is a sequence of one.
+export function parseKeySequence(input: string): KeyBinding[] | null {
+  const strokes = input.trim().split(/\s+/);
+  if (strokes.length > MAX_SEQUENCE_STROKES) return null;
+  const parsed = strokes.map(parseKeyBinding);
+  return parsed.every((stroke): stroke is KeyBinding => stroke !== null) ? parsed : null;
+}
+
+// Esc with no modifier always ends a sequence's wait, so it can never be a sequence's second key.
+export const isBareEscape = (e: KeymapKeyEvent): boolean => e.key === "Escape" && !e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey;
+
+// Actions that can be bound to a sequence. Not `copy` / `paste`: they are decided inside the
+// terminal, one keystroke at a time (TERMINAL_SCOPED_ACTIONS), and nothing there can wait.
+export const takesSequence = (action: KeymapAction): boolean => !TERMINAL_SCOPED_ACTIONS.includes(action);
+
+/** One action bound to two keystrokes. */
+export interface SequenceBinding {
+  action: KeymapAction;
+  first: KeyBinding;
+  second: KeyBinding;
+  /** How the user wrote each keystroke, for the hint shown while waiting for the second. */
+  firstLabel: string;
+  secondLabel: string;
+}
+
+// Every two-keystroke binding in a keymap, in action order.
+export function sequenceBindings(keymap: Keymap): SequenceBinding[] {
+  return KEYMAP_ACTIONS.flatMap((action): SequenceBinding[] => {
+    const raw = keymap[action];
+    const strokes = raw === undefined || !takesSequence(action) ? null : parseKeySequence(raw);
+    const [first, second] = strokes ?? [];
+    const [firstLabel, secondLabel] = raw?.trim().split(/\s+/) ?? [];
+    return first && second && firstLabel && secondLabel ? [{ action, first, second, firstLabel, secondLabel }] : [];
+  });
+}
+
 // The structural shape of a keydown a binding is matched against. A real KeyboardEvent
 // satisfies it, and so does a plain test object — no DOM dependency.
 export interface KeymapKeyEvent {
@@ -159,6 +204,7 @@ export function actionForKey(keymap: Keymap, e: KeymapKeyEvent): KeymapAction |
   for (const action of KEYMAP_ACTIONS) {
     const raw = keymap[action];
     if (raw === undefined) continue;
+    // A sequence is resolved by prefixStep (src/composables/prefixKeys.ts), never here.
     const binding = parseKeyBinding(raw);
     if (binding && matchesBinding(binding, e)) return action;
   }
@@ -215,26 +261,62 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
   // deliberately, so Ctrl+C stays an interrupt — and the same-key send fires then. Naming `copy`
   // as the winner there tells the user the opposite of what they will see half the time (#1901).
   const bound = new Map<string, Claim[]>();
-  const claim = (parsed: KeyBinding, entry: Claim): void => {
-    const key = canonicalBinding(parsed); // as PARSED: "Shift+PageUp" and "shift+pageup" are one keystroke
+  const claim = (strokes: KeyBinding[], entry: Claim): void => {
+    const key = canonicalSequence(strokes); // as PARSED: "Shift+PageUp" and "shift+pageup" are one keystroke
     bound.set(key, [...(bound.get(key) ?? []), entry]);
   };
-  const problems = entries.flatMap(([action, binding]): KeymapProblem[] => {
-    if (action === "send") return sendProblems(binding, claim);
-    if (!isKeymapAction(action)) {
-      return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")}, send)`, fatal: false }];
-    }
-    if (typeof binding !== "string") return [{ action, binding, reason: "binding must be a string", fatal: true }];
-    const parsed = parseKeyBinding(binding);
-    if (parsed === null) {
-      return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown" or "Shift+PageUp"', fatal: true }];
-    }
-    claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action), kind: "action" });
-    return unshiftedUnderCmdWarnings(action, binding, parsed);
+  const problems = entries.flatMap(([action, binding]): KeymapProblem[] =>
+    action === "send" ? sendProblems(binding, claim) : actionProblems(action, binding, claim),
+  );
+  return [...problems, ...duplicateWarnings(bound), ...prefixWarnings(bound)];
+}
+
+// Everything wrong with one action's binding, claiming its keystrokes when it is well-formed.
+function actionProblems(action: string, binding: unknown, claim: (strokes: KeyBinding[], entry: Claim) => void): KeymapProblem[] {
+  if (!isKeymapAction(action)) {
+    return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")}, send)`, fatal: false }];
+  }
+  if (typeof binding !== "string") return [{ action, binding, reason: "binding must be a string", fatal: true }];
+  const strokes = parseKeySequence(binding);
+  if (strokes === null) {
+    return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown", "Shift+PageUp" or two keys "Cmd+K p"', fatal: true }];
+  }
+  if (strokes.length > 1 && !takesSequence(action)) {
+    return [{ action, binding, reason: "takes a single keystroke — it is decided inside the terminal, which cannot wait for a second key", fatal: true }];
+  }
+  claim(strokes, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action), kind: "action" });
+  return [...strokes.flatMap((stroke) => unshiftedUnderCmdWarnings(action, binding, stroke)), ...escapeSecondWarnings(action, binding, strokes)];
+}
+
+const escapeSecondWarnings = (action: string, binding: string, [, second]: KeyBinding[]): KeymapProblem[] =>
+  second && isBareEscape({ key: second.key, shiftKey: second.shift, altKey: second.alt, ctrlKey: second.ctrl, metaKey: second.meta })
+    ? [{ action, binding, reason: "never fires — a bare Escape always cancels a sequence; add a modifier or pick another second key", fatal: false }]
+    : [];
+
+// A sequence whose FIRST key is also a keystroke of its own. The single keystroke is claimed before
+// any sequence can start (see GridView's handler), so the sequence never gets its first key.
+function prefixWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
+  return [...bound.entries()].flatMap(([key, claims]) => {
+    const [first, second] = key.split(SEQUENCE_SEPARATOR);
+    const singles = second === undefined || first === undefined ? [] : (bound.get(first) ?? []);
+    if (singles.length === 0) return [];
+    const reason = prefixCollision(singles);
+    return claims.map((claim) => ({ action: claim.label, binding: claim.binding, reason, fatal: false }));
   });
-  return [...problems, ...duplicateWarnings(bound)];
 }
 
+// Deliberately NOT a prediction of the states the sequence still starts in. Which single binding
+// acts depends on the zoom state, on a selection for `copy`, and on which of several claims dispatch
+// reaches — twice a narrower sentence was wrong for a combination it did not list (codex on #2283).
+// Every claim is named, in dispatch order, and the advice is the one that is always right.
+const prefixCollision = (singles: Claim[]): string => {
+  const names = [...singles]
+    .sort((x, y) => x.rank - y.rank)
+    .map((claim) => `\`${claim.label}\``)
+    .join(", ");
+  return `its first key is also bound on its own, to ${names} — those take the key whenever they act, so this sequence may never start; give it a first key nothing else uses`;
+};
+
 // A binding that says one keystroke and waits for another. While Cmd is held, a macOS browser puts
 // the UNSHIFTED character in `KeyboardEvent.key` — Cmd+Shift+P arrives as `"p"` — so a binding
 // written `"Cmd+Shift+P"` waits for a `"P"` that never comes, and nothing downstream can see the
@@ -273,7 +355,7 @@ interface Claim {
 // Fatal throughout, for the reason the module header gives: a send binding is invisible until
 // the key is pressed, so a dropped one is indistinguishable from a shortcut that "doesn't work".
 // Empty `bytes` is fatal too — it would take the key away from the terminal and put nothing back.
-function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim) => void): KeymapProblem[] {
+function sendProblems(input: unknown, claim: (strokes: KeyBinding[], entry: Claim) => void): KeymapProblem[] {
   if (!Array.isArray(input)) {
     return [{ action: "send", binding: input, reason: "`send` must be an array of { key, bytes }", fatal: true }];
   }
@@ -288,7 +370,7 @@ function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim)
       return [{ action: label, binding: entry.key, reason: "`bytes` is empty — the key would be taken from the terminal and nothing sent", fatal: true }];
     }
     // Ranked after every action, matching who actually wins (see the `bound` comment above).
-    claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i, kind: "send" });
+    claim([parsed], { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i, kind: "send" });
     return unshiftedUnderCmdWarnings(label, entry.key, parsed);
   });
 }
@@ -358,13 +440,25 @@ const collisionReason = (winner: Claim, runnerUp: Claim | null, loser: Claim): s
 // A binding's identity as a keystroke, for spotting two actions that claim the same one.
 const canonicalBinding = (b: KeyBinding): string => `${b.shift ? "S" : ""}${b.alt ? "A" : ""}${b.ctrl ? "C" : ""}${b.meta ? "M" : ""}|${b.key}`;
 
+// The same for a sequence. A keystroke's identity cannot contain the separator, because no key
+// does (parseKeyBinding refuses whitespace), so a sequence's first key splits back out exactly.
+const SEQUENCE_SEPARATOR = " ";
+const canonicalSequence = (strokes: KeyBinding[]): string => strokes.map(canonicalBinding).join(SEQUENCE_SEPARATOR);
+
+// A binding the dispatch can act on: it parses, and it is a single keystroke unless the action can
+// wait for a second one.
+const isUsableBinding = (action: KeymapAction, binding: string): boolean => {
+  const strokes = parseKeySequence(binding);
+  return strokes !== null && (strokes.length === 1 || takesSequence(action));
+};
+
 // Keep only known actions bound to a parseable, non-empty string. Unknown keys and
 // malformed bindings are dropped rather than rejecting the whole map, matching how the
 // rest of the config treats one bad entry.
 export function sanitizeKeymap(input: unknown): Keymap {
   if (!isRecord(input)) return {};
   const entries = Object.entries(input).filter(
-    (entry): entry is [KeymapAction, string] => isKeymapAction(entry[0]) && typeof entry[1] === "string" && parseKeyBinding(entry[1]) !== null,
+    (entry): entry is [KeymapAction, string] => isKeymapAction(entry[0]) && typeof entry[1] === "string" && isUsableBinding(entry[0], entry[1]),
   );
   const send = sanitizeSendBindings(input.send);
   return { ...Object.fromEntries(entries), ...(send.length ? { send } : {}) };

package/common/previewTheme.ts

@@ -0,0 +1,39 @@
+// The app's theme, carried to the Markdown preview (#2263). The preview is a sandboxed document the
+// app cannot style from outside, so the host hands it the few colours it paints with on the URL and
+// the server writes them into the document's own <style>.
+//
+// In `common/` because both ends decide from it: the pane builds the query, the server reads it.
+// Every value lands in CSS, so a colour is accepted only in the one shape the app's theme variables
+// use — `#` and hex digits — and any other value drops the WHOLE theme, leaving the document on the
+// reader's system colours as before. A partial theme could put dark text on a dark background.
+import { isPaletteColor } from "./themeColors.js";
+import type { ThemeVarKey, ThemeVars } from "./themeVars.js";
+
+/** Query parameter → the app theme variable it carries. */
+export const PREVIEW_THEME_PARAMS = {
+  bg: "--bg-base",
+  fg: "--text",
+  muted: "--text-secondary",
+  subtle: "--bg-subtle",
+  border: "--border",
+  link: "--accent",
+} as const satisfies Record<string, ThemeVarKey>;
+
+export type PreviewThemeParam = keyof typeof PREVIEW_THEME_PARAMS;
+export type PreviewTheme = Record<PreviewThemeParam, string>;
+
+/** Build a theme from named values, or null unless every one is a hex colour. */
+function themeOf(valueFor: (param: PreviewThemeParam) => unknown): PreviewTheme | null {
+  const colour = (param: PreviewThemeParam): string | null => {
+    const value = valueFor(param);
+    return isPaletteColor(value) ? value : null;
+  };
+  const [bg, fg, muted, subtle, border, link] = [colour("bg"), colour("fg"), colour("muted"), colour("subtle"), colour("border"), colour("link")];
+  return bg && fg && muted && subtle && border && link ? { bg, fg, muted, subtle, border, link } : null;
+}
+
+/** The preview's colours from the app's theme variables. */
+export const previewThemeFromVars = (vars: ThemeVars): PreviewTheme | null => themeOf((param) => vars[PREVIEW_THEME_PARAMS[param]]);
+
+/** The preview's colours from a request's query, or null when any is missing or not a hex colour. */
+export const previewThemeFromQuery = (query: Record<string, unknown>): PreviewTheme | null => themeOf((param) => query[param]);

package/common/themeVars.ts

@@ -129,11 +129,16 @@ export function relativeLuminance(color: string): number | null {
 // thinks about it still gets legible pills.
 const LIGHT_LUMINANCE_THRESHOLD = 0.4;
 
-export function isLightTheme(vars: ThemeVars): boolean {
-  const luminance = relativeLuminance(vars["--bg-base"]);
+/** Whether a background colour reads as light — the same line `isLightTheme` draws for the chrome. */
+export function isLightColor(color: string): boolean {
+  const luminance = relativeLuminance(color);
   return luminance !== null && luminance > LIGHT_LUMINANCE_THRESHOLD;
 }
 
+export function isLightTheme(vars: ThemeVars): boolean {
+  return isLightColor(vars["--bg-base"]);
+}
+
 /** The xterm palette a theme's variables imply. xterm draws on a canvas and cannot read CSS
  *  variables, so the same colours have to reach it as values — derived here rather than asked
  *  for twice, since two copies of one colour is two chances to change only one. The 16 ANSI

package/dist/assets/{abnfDiagram-O67JEVCF-DxIs7k89.js → abnfDiagram-O67JEVCF-0EIO6Rib.js}

@@ -1 +1 @@
-import{m as e,t}from"./mermaid-parser.core-B5FlVjCr.js";import{n}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as r}from"./src-CllyRBe0.js";import"./chunk-O7XYJQB3-LuTg7vRC.js";import{n as i,r as a,t as o}from"./chunk-GTNCS2PH-Dww8IZlE.js";import{t as s}from"./chunk-JWPE2WC7-DVXcaiue.js";import"./mermaid.core--DeGxg9T.js";var c=e().RailroadAbnf.parser.LangiumParser,l=n(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=n(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=n(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=n(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=n(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=n(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=n(e=>{s(e,o),e.title&&o.setTitle(e.title),e.rules.map(e=>o.addRule(m(e)))},`populateDb`),g={parser:{parse:n(e=>{o.clear(),r.debug(`[ABNF Parser] Starting Langium parse`);let n=c.parse(e);if(n.lexerErrors.length>0||n.parserErrors.length>0)throw new t(n);let i=n.value;r.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),r.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:o}},db:o,renderer:a,styles:i};export{g as diagram};
+import{m as e,t}from"./mermaid-parser.core-Dlf5XX-m.js";import{n}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as r}from"./src-CllyRBe0.js";import"./chunk-O7XYJQB3-C_ibJVHM.js";import{n as i,r as a,t as o}from"./chunk-GTNCS2PH-CabGHxDI.js";import{t as s}from"./chunk-JWPE2WC7-DVXcaiue.js";import"./mermaid.core-77q0N4Kj.js";var c=e().RailroadAbnf.parser.LangiumParser,l=n(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=n(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=n(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=n(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=n(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=n(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=n(e=>{s(e,o),e.title&&o.setTitle(e.title),e.rules.map(e=>o.addRule(m(e)))},`populateDb`),g={parser:{parse:n(e=>{o.clear(),r.debug(`[ABNF Parser] Starting Langium parse`);let n=c.parse(e);if(n.lexerErrors.length>0||n.parserErrors.length>0)throw new t(n);let i=n.value;r.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),r.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:o}},db:o,renderer:a,styles:i};export{g as diagram};

package/dist/assets/architecture-7GRP2DOG-BrJq_YrR.js

@@ -0,0 +1 @@
+import"./chunk-FOHPRMQF-DzxwRta7.js";import{M as e}from"./mermaid-parser.core-Dlf5XX-m.js";export{e as createArchitectureServices};