nex_shift/src/styles.css

4509 lines
87 KiB
CSS
Raw Normal View History

:root {
font-family:
-apple-system, BlinkMacSystemFont, "SF Pro Display", "Segoe UI", "PingFang SC",
"Hiragino Sans GB", "Microsoft YaHei", sans-serif;
color: #342019;
background: transparent;
font-synthesis: none;
text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased;
--ink: #342019;
--muted: #7d6256;
--orange: #f26a33;
--orange-deep: #d94f1f;
--cream: #fff6ee;
--paper: #fbf7f2;
--line: rgba(89, 51, 34, 0.1);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
/* One type ladder for every view: the panels used to size text per rule and
drifted down to 7-8 px, which is unreadable on a laptop at arm's length. */
--text-3xs: 11px;
--text-2xs: 12.5px;
--text-xs: 13.5px;
--text-sm: 14.5px;
--text-md: 16px;
--text-lg: 18px;
--text-xl: 21px;
--text-hero: clamp(28px, 3vw, 38px);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
/* A control that cannot be used reads the same everywhere: dimmed, no pointer,
no hover answer. Each panel used to invent its own dimming. */
--dimmed: 0.55;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
--radius-sm: 13px;
--radius-md: 16px;
}
* {
box-sizing: border-box;
}
html,
body,
#root {
width: 100%;
height: 100%;
margin: 0;
}
body {
overflow: hidden;
}
body[data-view="main"] {
background: #f5eee7;
}
body[data-view="radial"],
body[data-view="capture"],
body[data-view="recorder"],
2026-10-25 04:24:05 +00:00
body[data-view="pin"],
body[data-view="result-card"],
2026-10-25 04:24:05 +00:00
body[data-view="share-notice"] {
background: transparent;
}
2026-10-25 04:24:05 +00:00
/* Windows pins use an opaque native surface; a matching page background
prevents WebView2 from painting white before the image is decoded. */
html:has(body[data-view="pin"]),
html:has(body[data-view="pin"]) body,
html:has(body[data-view="pin"]) #root {
background: #201b18;
}
body[data-view="pin"] {
background: #201b18;
}
body[data-view="editor"] {
background: #f4efe9;
}
button,
input,
textarea {
font: inherit;
}
button {
color: inherit;
}
button:focus-visible,
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
input:focus-visible,
textarea:focus-visible,
a:focus-visible {
outline: 2px solid rgba(242, 106, 51, 0.58);
outline-offset: 2px;
}
[data-tauri-drag-region] {
-webkit-user-select: none;
user-select: none;
}
.spin {
animation: spin 0.9s linear infinite;
}
@keyframes spin {
to {
transform: rotate(360deg);
}
}
/* ------------------------------------------------------------------------- */
/* Main window */
/* ------------------------------------------------------------------------- */
kbd {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
min-width: 24px;
height: 22px;
display: inline-grid;
place-items: center;
padding: 0 6px;
border: 1px solid rgba(80, 47, 29, 0.12);
border-bottom-width: 2px;
border-radius: 6px;
color: #5e4337;
background: rgba(255, 255, 255, 0.86);
font-family: inherit;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 700;
}
.main-toast {
position: fixed;
left: 50%;
bottom: 26px;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
/* Above every sheet of this window (settings 40, share 61, setup 60), so a
result never lands behind the panel that caused it. */
z-index: 70;
max-width: min(620px, 80vw);
transform: translateX(-50%);
padding: 12px 18px;
border: 1px solid rgba(255, 255, 255, 0.25);
border-radius: 14px;
color: white;
background: rgba(44, 28, 22, 0.88);
box-shadow: 0 16px 46px rgba(42, 22, 14, 0.25);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
backdrop-filter: blur(18px);
animation: toast-in 0.22s ease-out;
}
@keyframes toast-in {
from {
opacity: 0;
transform: translate(-50%, 8px);
}
}
/* ------------------------------------------------------------------------- */
/* Radial menu */
/* ------------------------------------------------------------------------- */
.radial-stage {
position: relative;
width: 760px;
height: 760px;
overflow: hidden;
user-select: none;
-webkit-user-select: none;
animation: radial-enter 0.16s cubic-bezier(0.2, 0.9, 0.2, 1);
}
.radial-waiting {
background: transparent;
animation: none;
}
@keyframes radial-enter {
from {
opacity: 0;
transform: scale(0.96);
}
}
.radial-ambient {
position: absolute;
inset: 34px;
border-radius: 50%;
background:
radial-gradient(circle at 48% 42%, rgba(255, 252, 248, 0.44), transparent 52%),
radial-gradient(circle at 58% 62%, rgba(255, 175, 116, 0.16), transparent 60%);
filter: blur(6px);
pointer-events: none;
}
.radial-glass {
position: absolute;
left: 50%;
top: 50%;
width: 636px;
height: 636px;
transform: translate(-50%, -50%);
border-radius: 50%;
background: radial-gradient(
circle,
transparent 0 127px,
rgba(255, 247, 239, 0.42) 128px 100%
);
-webkit-mask: radial-gradient(circle at 50% 50%, transparent 0 127px, #000 128px);
mask: radial-gradient(circle at 50% 50%, transparent 0 127px, #000 128px);
backdrop-filter: blur(24px) saturate(1.08);
-webkit-backdrop-filter: blur(24px) saturate(1.08);
pointer-events: none;
}
.radial-svg {
position: absolute;
inset: 0;
overflow: visible;
pointer-events: none;
}
.radial-wedge {
pointer-events: all;
cursor: pointer;
}
.radial-wedge path {
transition:
fill 0.14s ease,
stroke 0.14s ease,
filter 0.14s ease;
}
.radial-wedge:hover path,
.radial-wedge.is-active path {
fill: url("#radialHot");
stroke: rgba(255, 255, 255, 0.88);
filter: drop-shadow(0 8px 11px rgba(161, 76, 38, 0.14));
}
.radial-label {
position: absolute;
z-index: 5;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 7px;
width: 104px;
min-height: 54px;
padding: 2px;
border: 0;
color: #2d1a11;
background: transparent;
transform: translate(-50%, -50%);
cursor: pointer;
transition:
color 0.14s ease,
transform 0.14s ease;
}
.radial-label svg {
color: #3f2a1e;
transition: transform 0.16s ease;
}
.radial-label span {
max-width: 100px;
overflow: hidden;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-xs);
font-weight: 720;
line-height: 1.02;
letter-spacing: -0.01em;
text-align: center;
text-transform: uppercase;
text-overflow: ellipsis;
white-space: nowrap;
}
.radial-label.is-active {
color: #24120a;
transform: translate(-50%, -50%) scale(1.08);
}
.radial-label.is-active svg {
color: #1c0d06;
transform: translateY(-2px);
}
.radial-label.is-format {
gap: 0;
}
.radial-label.is-format span {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-sm);
font-weight: 780;
letter-spacing: 0.08em;
}
.radial-center {
position: absolute;
left: 380px;
top: 380px;
z-index: 6;
width: 244px;
height: 244px;
display: block;
padding: 0;
transform: translate(-50%, -50%);
overflow: hidden;
border: 1px solid rgba(255, 255, 255, 0.5);
border-radius: 50%;
background: radial-gradient(
circle at 42% 22%,
rgba(255, 255, 255, 0.72),
rgba(255, 247, 240, 0.38) 62%,
rgba(255, 247, 240, 0.12)
);
box-shadow:
0 16px 36px rgba(92, 46, 25, 0.12),
inset 0 1px 0 rgba(255, 255, 255, 0.7);
backdrop-filter: blur(12px);
pointer-events: none;
}
.radial-center::after {
display: none;
}
2026-10-25 04:24:05 +00:00
.radial-progress,
.radial-error {
position: absolute;
inset: 0;
z-index: 9;
border-radius: 50%;
}
.radial-progress {
display: grid;
place-items: center;
padding: 38px;
background: radial-gradient(
circle at 45% 32%,
rgba(255, 252, 248, 0.94),
rgba(255, 241, 230, 0.84)
);
box-shadow: inset 0 0 36px rgba(242, 106, 51, 0.08);
pointer-events: none;
}
.radial-progress-ring {
position: absolute;
inset: 8px;
border-radius: 50%;
background: conic-gradient(
from 0deg,
rgba(242, 106, 51, 0) 0deg,
rgba(242, 106, 51, 0.08) 100deg,
var(--orange) 290deg,
#ffd3b9 350deg,
rgba(242, 106, 51, 0) 360deg
);
-webkit-mask: radial-gradient(circle, transparent calc(100% - 7px), #000 calc(100% - 6px));
mask: radial-gradient(circle, transparent calc(100% - 7px), #000 calc(100% - 6px));
animation: radial-progress-spin 1.05s linear infinite;
}
.radial-progress-content {
position: relative;
z-index: 1;
width: 150px;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 10px;
color: #6b402f;
text-align: center;
}
.radial-progress-content svg {
flex: none;
color: var(--orange-deep);
}
.radial-progress-content strong {
display: -webkit-box;
overflow: hidden;
color: #4b2c20;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 720;
line-height: 1.4;
overflow-wrap: anywhere;
-webkit-box-orient: vertical;
-webkit-line-clamp: 3;
}
@keyframes radial-progress-spin {
to {
transform: rotate(360deg);
}
}
.radial-error {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 5px;
padding: 34px 30px 27px;
color: #593728;
text-align: center;
background: radial-gradient(
circle at 45% 30%,
rgba(255, 252, 248, 0.99),
rgba(255, 237, 225, 0.96)
);
pointer-events: auto;
}
.radial-error > svg {
flex: none;
color: var(--orange-deep);
}
.radial-error strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 760;
}
.radial-error-message {
max-height: 78px;
overflow: auto;
padding: 0 5px;
color: #7a5544;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 550;
line-height: 1.4;
overflow-wrap: anywhere;
scrollbar-width: none;
}
.radial-error-message::-webkit-scrollbar {
display: none;
}
.radial-error button {
position: absolute;
top: 36px;
right: 36px;
width: 24px;
height: 24px;
display: grid;
place-items: center;
padding: 0;
border: 1px solid rgba(126, 75, 48, 0.14);
border-radius: 50%;
color: #805a48;
background: rgba(255, 255, 255, 0.74);
cursor: pointer;
}
.radial-error button:hover {
color: #3e2419;
background: white;
}
.radial-preview {
position: absolute;
left: 50%;
top: 50%;
z-index: 2;
width: 104px;
height: 104px;
object-fit: cover;
border: 3px solid rgba(255, 255, 255, 0.8);
border-radius: 20px;
box-shadow: 0 12px 26px rgba(92, 46, 25, 0.18);
transform: translate(-50%, -50%);
}
.radial-stage.is-formats .radial-preview {
width: 112px;
height: 112px;
border-radius: 22px;
}
.radial-file-stack {
position: absolute;
left: 50%;
top: 50%;
width: 120px;
height: 100px;
transform: translate(-50%, -50%);
}
.radial-stack-card {
position: absolute;
left: 50%;
top: 50%;
width: 82px;
height: 82px;
display: grid;
place-items: center;
border: 2px solid rgba(255, 255, 255, 0.9);
border-radius: 20px;
color: #d25b2a;
background: linear-gradient(145deg, #fff9f4, #ffe4d0);
box-shadow: 0 10px 22px rgba(92, 46, 25, 0.16);
}
.radial-stack-card.card-0 {
z-index: 1;
background: #ffe4cd;
transform: translate(-50%, -50%) translate(-22px, -12px) rotate(-9deg);
}
.radial-stack-card.card-1 {
z-index: 2;
background: #fffdfa;
transform: translate(-50%, -50%) translate(22px, 12px) rotate(9deg);
}
.radial-stack-card.card-2 {
z-index: 3;
background: #fff;
transform: translate(-50%, -50%);
}
.radial-fallback {
position: absolute;
left: 50%;
top: 50%;
z-index: 2;
width: 104px;
height: 104px;
display: grid;
place-items: center;
border-radius: 20px;
color: #d25b2a;
background: linear-gradient(145deg, #fff5ec, #ffe2cd);
box-shadow: 0 12px 26px rgba(92, 46, 25, 0.12);
transform: translate(-50%, -50%);
}
.radial-stage.is-formats .radial-fallback {
width: 112px;
height: 112px;
border-radius: 22px;
}
.radial-center-info {
position: absolute;
left: 50%;
bottom: 10px;
z-index: 3;
width: 190px;
max-width: 84%;
display: flex;
flex-direction: column;
align-items: center;
gap: 4px;
transform: translateX(-50%);
}
.radial-size-pill {
position: static;
padding: 3px 10px;
border: 1px solid rgba(255, 255, 255, 0.6);
border-radius: 999px;
color: #5b3a2b;
background: rgba(255, 255, 255, 0.72);
box-shadow: none;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-3xs);
font-weight: 650;
backdrop-filter: blur(8px);
}
.radial-file-pill {
position: static;
max-width: 168px;
overflow: hidden;
padding: 5px 9px;
border: 1px solid rgba(255, 255, 255, 0.28);
border-radius: 7px;
color: white;
background: #1677ff;
box-shadow: 0 6px 16px rgba(18, 88, 191, 0.2);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 690;
letter-spacing: -0.01em;
text-overflow: ellipsis;
white-space: nowrap;
pointer-events: none;
}
.radial-drag-file {
position: absolute;
z-index: 20;
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 6px;
pointer-events: none;
}
.radial-drag-file img {
width: 104px;
height: 104px;
object-fit: cover;
border: 3px solid rgba(255, 255, 255, 0.9);
border-radius: 18px;
box-shadow: 0 16px 34px rgba(54, 28, 16, 0.28);
}
.radial-drag-file span {
max-width: 170px;
overflow: hidden;
padding: 5px 9px;
border-radius: 7px;
color: white;
background: #1677ff;
box-shadow: 0 8px 20px rgba(18, 88, 191, 0.25);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 690;
letter-spacing: -0.01em;
text-overflow: ellipsis;
white-space: nowrap;
}
/* The figure a Recent row carries while it is dragged: one file with its name, the
same shape the ring draws for the file it is about to convert. Off flow and off
screen, because the engine photographs it at `dragstart` and the page should never
show it. */
.file-drag-ghost {
position: fixed;
top: -240px;
left: 0;
z-index: -1;
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 6px;
pointer-events: none;
}
.file-drag-art {
display: grid;
place-items: center;
width: 104px;
height: 104px;
border: 3px solid rgba(255, 255, 255, 0.9);
border-radius: 18px;
background: linear-gradient(150deg, #efe6ff, #dcd0fb);
box-shadow: 0 16px 34px rgba(54, 28, 16, 0.28);
color: #6b53c8;
font-size: 19px;
font-weight: 750;
letter-spacing: 0.02em;
text-transform: uppercase;
}
.file-drag-art.is-image {
background: #fffdf9;
}
.file-drag-art img {
width: 100%;
height: 100%;
object-fit: cover;
border-radius: 15px;
}
.file-drag-ghost > span {
max-width: 170px;
overflow: hidden;
padding: 5px 9px;
border-radius: 7px;
color: #fff;
background: #1677ff;
box-shadow: 0 8px 20px rgba(18, 88, 191, 0.25);
font-size: 12px;
font-weight: 690;
letter-spacing: -0.01em;
text-overflow: ellipsis;
white-space: nowrap;
}
.radial-hint {
position: absolute;
left: 50%;
bottom: 22px;
z-index: 15;
display: flex;
align-items: center;
gap: 6px;
max-width: 490px;
transform: translateX(-50%);
padding: 9px 16px;
border: 1px solid rgba(255, 255, 255, 0.46);
border-radius: 999px;
color: #604032;
background: rgba(255, 248, 241, 0.76);
box-shadow: 0 9px 28px rgba(74, 37, 20, 0.12);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-2xs);
font-weight: 560;
white-space: nowrap;
backdrop-filter: blur(16px);
}
.radial-hint b {
margin-left: 2px;
color: var(--orange-deep);
font-weight: 760;
}
.radial-hint span {
color: #ae9385;
}
/* ------------------------------------------------------------------------- */
/* Capture overlay */
/* ------------------------------------------------------------------------- */
.capture-loading {
position: fixed;
inset: 0;
background: #171313;
}
.capture-stage {
position: fixed;
inset: 0;
overflow: hidden;
cursor: crosshair;
touch-action: none;
user-select: none;
-webkit-user-select: none;
}
.capture-stage.is-dragging {
cursor: crosshair;
}
.capture-screen {
position: absolute;
inset: 0;
width: 100%;
height: 100%;
object-fit: fill;
pointer-events: none;
}
.capture-dim {
position: absolute;
inset: 0;
pointer-events: none;
background: rgba(20, 15, 17, 0.28);
}
.capture-selection {
position: absolute;
z-index: 2;
border: 1.5px solid rgba(255, 255, 255, 0.96);
background: transparent;
box-shadow:
0 0 0 100vmax rgba(16, 12, 14, 0.56),
0 0 0 1px rgba(0, 0, 0, 0.16),
inset 0 0 0 1px rgba(255, 255, 255, 0.2);
pointer-events: none;
}
.capture-corner {
position: absolute;
width: 13px;
height: 13px;
border-color: white;
border-style: solid;
}
.capture-corner-tl {
left: -2px;
top: -2px;
border-width: 3px 0 0 3px;
border-radius: 4px 0 0;
}
.capture-corner-tr {
right: -2px;
top: -2px;
border-width: 3px 3px 0 0;
border-radius: 0 4px 0 0;
}
.capture-corner-bl {
left: -2px;
bottom: -2px;
border-width: 0 0 3px 3px;
border-radius: 0 0 0 4px;
}
.capture-corner-br {
right: -2px;
bottom: -2px;
border-width: 0 3px 3px 0;
border-radius: 0 0 4px;
}
.capture-size-chip {
position: absolute;
top: -31px;
left: 0;
padding: 5px 8px;
border-radius: 7px;
color: white;
background: rgba(26, 22, 23, 0.78);
box-shadow: 0 4px 14px rgba(0, 0, 0, 0.16);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-variant-numeric: tabular-nums;
font-weight: 620;
backdrop-filter: blur(12px);
}
.capture-toolbar {
position: absolute;
z-index: 10;
display: flex;
align-items: center;
gap: 6px;
padding: 6px;
border: 1px solid rgba(255, 255, 255, 0.18);
border-radius: 13px;
background: rgba(31, 25, 26, 0.82);
box-shadow: 0 14px 40px rgba(0, 0, 0, 0.26);
cursor: default;
backdrop-filter: blur(16px);
}
.capture-tool {
display: inline-flex;
align-items: center;
justify-content: center;
gap: 6px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 36px;
padding: 0 10px;
border: 0;
border-radius: 8px;
color: rgba(255, 255, 255, 0.85);
background: rgba(255, 255, 255, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 650;
cursor: pointer;
}
.capture-tool:hover {
background: rgba(255, 255, 255, 0.15);
}
.capture-tool.is-selected {
color: #ffc9ae;
background: rgba(242, 106, 51, 0.2);
}
.capture-confirm {
color: #28140d;
background: #fff5ec;
}
.capture-confirm:hover {
background: white;
}
.capture-record {
color: white;
background: #e64f52;
}
.capture-record:hover {
background: #f15b5e;
}
.capture-start-hint {
position: absolute;
left: 50%;
bottom: 54px;
z-index: 8;
display: flex;
align-items: center;
gap: 12px;
transform: translateX(-50%);
padding: 11px 12px 11px 11px;
border: 1px solid rgba(255, 255, 255, 0.16);
border-radius: 17px;
color: white;
background: rgba(28, 23, 24, 0.78);
box-shadow: 0 18px 45px rgba(0, 0, 0, 0.25);
backdrop-filter: blur(18px);
}
.capture-icon {
width: 38px;
height: 38px;
display: grid;
place-items: center;
border-radius: 11px;
color: #ffb88f;
background: rgba(242, 106, 51, 0.15);
}
.capture-start-hint > div {
display: flex;
flex-direction: column;
gap: 2px;
padding-right: 10px;
}
.capture-start-hint strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-md);
font-weight: 680;
}
.capture-start-hint span {
color: rgba(255, 255, 255, 0.56);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
}
.capture-start-hint kbd {
border-color: rgba(255, 255, 255, 0.12);
color: rgba(255, 255, 255, 0.65);
background: rgba(255, 255, 255, 0.08);
}
.capture-processing,
.capture-status {
position: absolute;
left: 50%;
bottom: 30px;
z-index: 12;
display: flex;
align-items: center;
gap: 8px;
transform: translateX(-50%);
padding: 9px 14px;
border: 1px solid rgba(255, 255, 255, 0.14);
border-radius: 11px;
color: white;
background: rgba(27, 22, 23, 0.82);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.22);
backdrop-filter: blur(14px);
}
/* ------------------------------------------------------------------------- */
/* Recorder HUD */
/* ------------------------------------------------------------------------- */
.recorder-hud {
width: 300px;
height: 88px;
display: flex;
align-items: center;
gap: 11px;
padding: 13px;
border: 1px solid rgba(255, 255, 255, 0.13);
border-radius: 22px;
color: white;
background:
linear-gradient(135deg, rgba(50, 35, 32, 0.94), rgba(28, 22, 24, 0.92));
box-shadow:
0 18px 50px rgba(18, 10, 8, 0.3),
inset 0 1px 0 rgba(255, 255, 255, 0.08);
backdrop-filter: blur(24px);
}
.recorder-pulse {
width: 38px;
height: 38px;
flex: none;
display: grid;
place-items: center;
border-radius: 12px;
color: #ff5c62;
background: rgba(255, 80, 90, 0.14);
animation: recorder-pulse 1.35s ease-in-out infinite;
}
@keyframes recorder-pulse {
50% {
box-shadow: 0 0 0 5px rgba(255, 86, 95, 0.08);
}
}
.recorder-copy {
flex: 1;
display: flex;
flex-direction: column;
gap: 2px;
}
.recorder-copy strong {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-lg);
font-variant-numeric: tabular-nums;
letter-spacing: 0.02em;
}
.recorder-copy span {
color: rgba(255, 255, 255, 0.48);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 650;
letter-spacing: 0.06em;
text-transform: uppercase;
}
.recorder-copy .recorder-error {
max-width: 130px;
overflow: hidden;
color: #ff9a9e;
text-transform: none;
white-space: nowrap;
text-overflow: ellipsis;
}
.recorder-stop {
height: 38px;
display: flex;
align-items: center;
gap: 6px;
padding: 0 12px;
border: 0;
border-radius: 11px;
color: white;
background: #e45155;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 680;
cursor: pointer;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.recorder-stop:hover:not(:disabled) {
background: #f05b5f;
}
.recorder-stop:disabled {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
cursor: default;
}
/* ------------------------------------------------------------------------- */
/* Editor */
/* ------------------------------------------------------------------------- */
.editor-loading {
width: 100%;
height: 100%;
background: #f4efe9;
}
.editor-shell {
position: relative;
width: 100%;
height: 100%;
display: flex;
flex-direction: column;
overflow: hidden;
background: #f4efe9;
}
.editor-titlebar {
2026-10-25 04:24:05 +00:00
position: relative;
z-index: 5;
flex: none;
display: grid;
2026-10-25 04:24:05 +00:00
grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
align-items: center;
gap: 20px;
2026-10-25 04:24:05 +00:00
height: 58px;
padding: 0 22px;
}
.editor-shell.is-mac .editor-titlebar {
padding-left: 86px;
}
.editor-title {
overflow: hidden;
2026-10-25 04:24:05 +00:00
color: #9c7e6d;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
2026-10-25 04:24:05 +00:00
font-weight: 540;
letter-spacing: -0.02em;
text-align: center;
text-overflow: ellipsis;
white-space: nowrap;
}
.editor-close {
justify-self: end;
}
.editor-toolbar {
flex: none;
height: 56px;
display: flex;
align-items: center;
justify-content: space-between;
padding: 0 20px;
border-bottom: 1px solid rgba(86, 52, 34, 0.08);
background: rgba(255, 255, 255, 0.56);
}
.editor-tool-group {
display: flex;
align-items: center;
gap: 7px;
}
.editor-button,
.editor-secondary,
.editor-primary {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 34px;
display: inline-flex;
align-items: center;
gap: 6px;
padding: 0 11px;
border: 1px solid rgba(89, 51, 34, 0.1);
border-radius: 9px;
color: #6c5041;
background: rgba(255, 255, 255, 0.65);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 620;
cursor: pointer;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.editor-button:hover:not(:disabled),
.editor-secondary:hover:not(:disabled) {
color: #44281b;
background: white;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.editor-button:disabled,
.editor-secondary:disabled {
opacity: var(--dimmed);
cursor: default;
}
.editor-button.is-active {
border-color: rgba(242, 106, 51, 0.28);
color: #c84c20;
background: #fff0e5;
}
.editor-primary {
border-color: transparent;
color: white;
background: #e85e2b;
}
.editor-primary:hover {
background: #f06a35;
}
.editor-icon {
width: 32px;
height: 32px;
display: grid;
place-items: center;
border: 0;
border-radius: 9px;
color: #8d7466;
background: transparent;
cursor: pointer;
}
.editor-icon:hover {
color: #4e3022;
background: rgba(105, 65, 43, 0.07);
}
.editor-main {
flex: 1;
min-height: 0;
display: flex;
overflow: hidden;
}
.editor-canvas {
position: relative;
flex: 1;
min-width: 0;
display: flex;
align-items: center;
justify-content: center;
overflow: auto;
padding: 26px;
background:
linear-gradient(45deg, rgba(255, 255, 255, 0.03) 25%, transparent 25%) 0 0 / 20px 20px,
linear-gradient(-45deg, rgba(255, 255, 255, 0.03) 25%, transparent 25%) 0 0 / 20px 20px,
linear-gradient(45deg, transparent 75%, rgba(255, 255, 255, 0.03) 75%) 0 0 / 20px 20px,
linear-gradient(-45deg, transparent 75%, rgba(255, 255, 255, 0.03) 75%) 0 0 / 20px 20px,
#252221;
}
.editor-canvas img,
.editor-canvas video {
display: block;
max-width: 100%;
max-height: calc(100vh - 170px);
border-radius: 10px;
box-shadow: 0 24px 65px rgba(0, 0, 0, 0.34);
}
.annotator-shell {
position: relative;
width: 100%;
height: 100%;
min-height: 0;
display: flex;
align-items: center;
justify-content: center;
padding: 66px 26px 26px;
}
.annotator-toolbar {
position: absolute;
top: 18px;
left: 50%;
z-index: 5;
display: flex;
align-items: center;
gap: 5px;
transform: translateX(-50%);
padding: 6px;
border: 1px solid rgba(255, 255, 255, 0.14);
border-radius: 12px;
background: rgba(34, 29, 28, 0.9);
box-shadow: 0 14px 34px rgba(0, 0, 0, 0.24);
backdrop-filter: blur(18px);
}
.annotator-tool {
flex: none;
height: 30px;
display: inline-flex;
align-items: center;
gap: 5px;
padding: 0 9px;
border: 0;
border-radius: 8px;
color: rgba(255, 255, 255, 0.75);
background: transparent;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 620;
white-space: nowrap;
cursor: pointer;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.annotator-tool:hover:not(:disabled) {
color: white;
background: rgba(255, 255, 255, 0.1);
}
.annotator-tool.is-active {
color: white;
background: rgba(255, 103, 52, 0.25);
}
.annotator-tool.is-primary {
color: #2b160e;
background: #fff1e5;
}
.annotator-tool:disabled {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
cursor: default;
}
.annotator-separator {
width: 1px;
height: 20px;
margin: 0 3px;
background: rgba(255, 255, 255, 0.13);
}
.annotator-canvas-wrap {
position: relative;
width: 100%;
height: 100%;
display: flex;
align-items: center;
justify-content: center;
overflow: auto;
}
.annotator-canvas-wrap canvas {
display: block;
max-width: 100%;
max-height: calc(100vh - 190px);
border-radius: 10px;
box-shadow: 0 24px 65px rgba(0, 0, 0, 0.34);
cursor: crosshair;
touch-action: none;
}
.annotator-error {
position: absolute;
left: 50%;
bottom: 18px;
max-width: 80%;
transform: translateX(-50%);
padding: 8px 12px;
border-radius: 9px;
color: white;
background: rgba(154, 46, 35, 0.9);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
}
.annotator-text-entry {
position: absolute;
left: 50%;
bottom: 18px;
z-index: 6;
display: flex;
align-items: center;
gap: 5px;
width: min(420px, 80%);
transform: translateX(-50%);
padding: 6px;
border: 1px solid rgba(255, 255, 255, 0.14);
border-radius: 11px;
background: rgba(34, 29, 28, 0.92);
box-shadow: 0 14px 34px rgba(0, 0, 0, 0.24);
backdrop-filter: blur(18px);
}
.annotator-text-entry input {
flex: 1;
min-width: 0;
height: 30px;
padding: 0 9px;
border: 0;
border-radius: 7px;
color: white;
background: rgba(255, 255, 255, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
outline: none;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.annotator-text-entry:focus-within {
border-color: rgba(242, 106, 51, 0.6);
}
.annotator-text-entry button {
width: 30px;
height: 30px;
display: grid;
place-items: center;
border: 0;
border-radius: 7px;
color: #2b160e;
background: #fff1e5;
cursor: pointer;
}
.editor-canvas video {
width: min(100%, 1000px);
background: black;
}
.editor-file-fallback {
display: flex;
flex-direction: column;
align-items: center;
gap: 14px;
color: rgba(255, 255, 255, 0.75);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-xs);
}
.editor-text-preview {
width: min(860px, 100%);
max-height: calc(100vh - 190px);
margin: 0;
overflow: auto;
padding: 24px;
border: 1px solid rgba(255, 255, 255, 0.08);
border-radius: 12px;
color: #f3ece7;
background: rgba(31, 28, 27, 0.92);
font-family: "SF Mono", "Cascadia Code", ui-monospace, monospace;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-2xs);
line-height: 1.7;
white-space: pre-wrap;
word-break: break-word;
box-shadow: 0 24px 65px rgba(0, 0, 0, 0.28);
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
.editor-path {
max-width: 360px;
overflow: hidden;
color: #85695c;
font-size: var(--text-3xs);
white-space: nowrap;
text-overflow: ellipsis;
}
.editor-file-fallback svg {
color: #ffa474;
}
.editor-file-fallback button {
padding: 8px 14px;
border: 0;
border-radius: 9px;
color: white;
background: rgba(255, 255, 255, 0.14);
cursor: pointer;
}
.ocr-panel {
flex: none;
width: 375px;
display: flex;
flex-direction: column;
padding: 20px;
border-left: 1px solid rgba(87, 52, 33, 0.1);
background: #fbf8f4;
}
.ocr-panel-head {
display: flex;
align-items: flex-start;
justify-content: space-between;
gap: 10px;
}
.ocr-eyebrow {
color: #c46b43;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 800;
letter-spacing: 0.13em;
}
.ocr-panel h2 {
margin: 5px 0 4px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-xl);
letter-spacing: -0.04em;
}
.ocr-panel p {
margin: 0;
color: #91796c;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
line-height: 1.45;
}
.ocr-progress {
margin: 18px 0 4px;
}
.ocr-progress-row {
display: flex;
align-items: center;
gap: 7px;
color: #7a5e50;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
}
.ocr-progress-row span {
flex: 1;
}
.ocr-progress-row b {
font-variant-numeric: tabular-nums;
}
.ocr-progress-bar {
height: 4px;
margin-top: 8px;
overflow: hidden;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
border-radius: 999px;
background: #ece1d9;
}
.ocr-progress-bar span {
display: block;
height: 100%;
border-radius: inherit;
background: linear-gradient(90deg, #ffad73, #ee6432);
transition: width 0.25s ease;
}
.ocr-output {
flex: 1;
width: 100%;
min-height: 0;
margin-top: 15px;
padding: 13px;
resize: none;
border: 1px solid rgba(90, 53, 34, 0.11);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
border-radius: var(--radius-sm);
color: #453025;
background: white;
font-family: "SF Mono", "Cascadia Code", ui-monospace, monospace;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
line-height: 1.6;
}
.ocr-output:focus {
outline: none;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
border-color: rgba(242, 106, 51, 0.42);
box-shadow: 0 0 0 3px rgba(242, 106, 51, 0.08);
}
.ocr-actions {
display: flex;
gap: 8px;
margin-top: 12px;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.editor-toast.is-error {
color: #ffe4dd;
background: rgba(126, 40, 22, 0.92);
}
.editor-toast {
position: absolute;
left: 50%;
bottom: 28px;
z-index: 20;
display: flex;
align-items: center;
gap: 7px;
transform: translateX(-50%);
padding: 9px 14px;
border-radius: 11px;
color: white;
background: rgba(41, 27, 21, 0.88);
box-shadow: 0 12px 32px rgba(42, 22, 14, 0.23);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
backdrop-filter: blur(14px);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
animation: toast-in 0.22s ease-out;
}
/* ------------------------------------------------------------------------- */
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
/* Home */
/* ------------------------------------------------------------------------- */
.home {
position: relative;
width: 100%;
height: 100%;
overflow: hidden;
background:
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
radial-gradient(circle at 12% -8%, rgba(255, 204, 168, 0.4), transparent 34%),
radial-gradient(circle at 92% 6%, rgba(218, 190, 255, 0.24), transparent 30%),
linear-gradient(180deg, #fbf7f2 0%, #f2ece6 100%);
}
.home-bar {
position: relative;
z-index: 5;
display: flex;
align-items: center;
justify-content: space-between;
gap: 20px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 64px;
padding: 0 24px;
}
.home.is-mac .home-bar {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding-left: 88px;
}
.home-brand {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 10px;
min-width: 160px;
}
.home-mark {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 26px;
height: 26px;
object-fit: contain;
filter: drop-shadow(0 5px 12px rgba(215, 84, 39, 0.2));
}
.home-brand strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #37221a;
font-size: var(--text-md);
font-weight: 700;
letter-spacing: -0.03em;
}
.home-brand-sub {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding-left: 10px;
border-left: 1px solid rgba(96, 60, 39, 0.13);
color: #9b7c6b;
font-size: var(--text-2xs);
font-weight: 560;
letter-spacing: -0.01em;
white-space: nowrap;
}
.home-bar-actions {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
}
.home-quick,
.home-icon-button {
display: inline-flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
height: 36px;
padding: 0 13px;
white-space: nowrap;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border: 1px solid rgba(91, 57, 38, 0.1);
border-radius: var(--radius-sm);
color: #573d31;
background: rgba(255, 255, 255, 0.66);
box-shadow: 0 4px 14px rgba(75, 45, 29, 0.04);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-xs);
font-weight: 620;
cursor: pointer;
backdrop-filter: blur(14px);
transition:
background 0.16s ease,
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color 0.16s ease,
color 0.16s ease;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.home-icon-button:hover:not(:disabled),
.home-quick:hover:not(:disabled) {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(242, 106, 51, 0.24);
color: #3f281e;
background: rgba(255, 255, 255, 0.94);
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.home-icon-button:disabled,
.home-quick:disabled {
opacity: var(--dimmed);
cursor: default;
}
.home-quick kbd {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-left: 1px;
min-width: 20px;
height: 20px;
padding: 0 5px;
border: 0;
border-radius: 5px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #8d6c5b;
background: rgba(104, 68, 48, 0.08);
font-size: var(--text-3xs);
font-weight: 640;
}
.home-icon-button {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 36px;
padding: 0;
justify-content: center;
}
.home-icon-button.is-active {
color: #d45729;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(242, 106, 51, 0.3);
background: #fff;
}
.update-system-host {
display: inline-flex;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
align-items: center;
gap: 7px;
min-width: 0;
color: #3f2a20;
font-family: "SF Mono", "Cascadia Code", ui-monospace, monospace;
font-size: var(--text-2xs);
font-style: normal;
font-weight: 600;
}
.update-system-host strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.update-system-host small,
.update-system-pending {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
flex: none;
padding: 2px 7px;
border-radius: 999px;
color: #6f5346;
background: rgba(104, 68, 48, 0.08);
font-family: inherit;
font-size: var(--text-3xs);
font-weight: 620;
}
.update-system-host em {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
flex: none;
color: #a3836f;
font-size: var(--text-3xs);
font-style: normal;
}
.home-main {
position: relative;
z-index: 2;
display: grid;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
grid-template-columns: minmax(0, 1fr) 372px;
gap: 18px;
height: calc(100% - 64px);
padding: 8px 26px 26px;
}
.home-drop {
position: relative;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
min-height: 0;
overflow: hidden;
padding: 36px;
border: 1px solid rgba(96, 60, 39, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 26px;
background: rgba(255, 252, 248, 0.72);
box-shadow:
0 20px 60px rgba(96, 56, 33, 0.06),
inset 0 1px 0 rgba(255, 255, 255, 0.8);
text-align: center;
backdrop-filter: blur(18px);
}
.permission-banner {
position: absolute;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
top: 18px;
left: 50%;
z-index: 3;
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 10px;
max-width: min(92%, 620px);
transform: translateX(-50%);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 10px 11px 10px 14px;
border: 1px solid rgba(217, 79, 31, 0.2);
border-radius: var(--radius-sm);
color: #76381f;
background: rgba(255, 241, 232, 0.94);
box-shadow: 0 8px 24px rgba(121, 55, 26, 0.1);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 600;
line-height: 1.4;
backdrop-filter: blur(12px);
}
.permission-banner svg {
flex: none;
color: #d94f1f;
}
.permission-banner button {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 28px;
padding: 0 11px;
border: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 8px;
color: #fff8f3;
background: #e45c2a;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 680;
cursor: pointer;
}
.permission-banner button:hover {
background: #d94f1f;
}
.home-drop::before {
content: "";
position: absolute;
left: 50%;
bottom: -190px;
width: 620px;
height: 360px;
transform: translateX(-50%);
border-radius: 50%;
background: radial-gradient(circle, rgba(255, 173, 117, 0.2), transparent 68%);
pointer-events: none;
}
.home-drop::after {
content: "";
position: absolute;
inset: 18px;
border: 1.5px dashed rgba(150, 99, 70, 0.19);
border-radius: 20px;
pointer-events: none;
}
.home-drop-art {
position: relative;
z-index: 1;
width: 250px;
height: 100px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-bottom: 24px;
}
.home-drop-card {
position: absolute;
left: calc(50% + var(--x));
bottom: var(--y);
display: grid;
place-items: center;
width: 54px;
height: 58px;
border: 2px solid rgba(255, 255, 255, 0.92);
border-radius: 15px;
box-shadow: 0 12px 26px rgba(91, 52, 31, 0.14);
transform: translateX(-50%) rotate(var(--angle));
transform-origin: 50% 130%;
}
.home-drop-card.tone-image {
color: #d25b2a;
background: #ffe2cc;
}
.home-drop-card.tone-pdf {
color: #7661c7;
background: #eee9ff;
}
.home-drop-card.tone-document {
color: #c08b2e;
background: #fff7e4;
}
.home-drop-card.tone-video {
color: #5c8fc8;
background: #e6f2ff;
}
.home-drop-card.tone-audio {
color: #cc6897;
background: #ffe8f2;
}
.home-drop-card.tone-sheet {
color: #5a9d75;
background: #e8f6ee;
}
.home-drop-card.tone-presentation {
color: #9763c5;
background: #f3e9ff;
}
.home-drop h1 {
position: relative;
z-index: 1;
margin: 0;
animation: home-rise 0.42s cubic-bezier(0.22, 0.68, 0.32, 1) both;
color: #322016;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-hero);
font-weight: 700;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
letter-spacing: -0.045em;
}
.home-primary-actions {
position: relative;
z-index: 1;
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 10px;
margin-top: 28px;
animation: home-rise 0.42s cubic-bezier(0.22, 0.68, 0.32, 1) 0.1s both;
}
.home-primary,
.home-secondary {
display: inline-flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 9px;
height: 46px;
padding: 0 20px;
border-radius: var(--radius-sm);
font-size: var(--text-md);
font-weight: 650;
letter-spacing: -0.015em;
cursor: pointer;
transition:
transform 0.16s ease,
box-shadow 0.16s ease,
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color 0.16s ease,
background 0.16s ease,
color 0.16s ease;
}
.home-primary {
border: 0;
color: #fff8f2;
background: linear-gradient(135deg, #ff8248, #eb5427);
box-shadow: 0 10px 24px rgba(228, 83, 39, 0.26);
}
.home-primary:hover {
transform: translateY(-1px);
box-shadow: 0 14px 28px rgba(228, 83, 39, 0.32);
}
.home-secondary {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border: 1px solid rgba(101, 64, 43, 0.12);
color: #573d30;
background: rgba(255, 255, 255, 0.76);
}
.home-secondary:hover {
2026-10-25 04:24:05 +00:00
transform: translateY(-1px);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(242, 106, 51, 0.24);
background: #fff;
2026-10-25 04:24:05 +00:00
box-shadow: 0 12px 24px rgba(96, 56, 33, 0.12);
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
/* Rows dragged out of Recent land here: the button keeps its own action. */
.home-drop-hint {
position: relative;
z-index: 1;
display: flex;
align-items: center;
gap: 6px;
margin: 16px 0 0;
animation: home-rise 0.42s cubic-bezier(0.22, 0.68, 0.32, 1) 0.14s both;
color: #9a7c6c;
font-size: var(--text-2xs);
font-weight: 560;
}
.home-drop-hint svg {
color: #cf7c4f;
}
/* Drop targets: the primary buttons double as "drop here for this action". */
.home-primary-actions.has-drop-target .home-primary,
.home-primary-actions.has-drop-target .home-secondary {
border-style: dashed;
border-color: rgba(242, 106, 51, 0.34);
}
2026-10-25 04:24:05 +00:00
/* The primary button has no border of its own, so the dashed hint needs one. */
.home-primary-actions.has-drop-target .home-primary {
border: 1px dashed rgba(242, 106, 51, 0.34);
}
.home-primary.is-drop-target,
.home-secondary.is-drop-target {
transform: translateY(-3px) scale(1.04);
border-color: rgba(242, 106, 51, 0.7);
box-shadow:
0 0 0 4px rgba(242, 106, 51, 0.16),
0 16px 30px rgba(228, 83, 39, 0.26);
}
.home-primary.is-drop-target {
background: linear-gradient(135deg, #ff9459, #f2602d);
}
.home-secondary.is-drop-target {
color: #c84c20;
background: #fff1e7;
}
/* The drag carries a file this button cannot serve, so the button is switched off for the
length of the gesture. The refusal is in the cursor as well — AppKit paints the
prohibition sign for a destination that reports it does not want the file, which
`src-tauri/src/drop_cursor.rs` arranges, and `dropEffect: none` does the same on
Chromium — and the button is the part that says it without a pointer at all.
Muted through its own colours rather than `opacity`, which is how the rest of the app
dims a control: a spent button has to read as switched off, not as still loading. */
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.home-primary.is-drop-unavailable,
.home-secondary.is-drop-unavailable {
border: 1px solid rgba(101, 64, 43, 0.14);
color: #b5a399;
background: rgba(255, 255, 255, 0.44);
box-shadow: none;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
transform: none;
/* The aim is measured by coordinates, not by which element answers the event, so a
switched-off button must stay out of the way: taking the hit area would stop the
drag events on it and leave the gesture pointing at the last button that answered.
It also means no hover feedback is even possible. */
pointer-events: none;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
}
/* A disabled control takes no hover feedback, so nothing may make a spent button look
reachable while the file is still in the air. */
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.home-primary.is-drop-unavailable:hover,
.home-secondary.is-drop-unavailable:hover {
border: 1px solid rgba(101, 64, 43, 0.14);
color: #b5a399;
background: rgba(255, 255, 255, 0.44);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
transform: none;
box-shadow: none;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
}
/* A candidate button is dashed while a file is in the air; a spent one keeps a plain
edge so the two states cannot be confused. */
.home-primary-actions.has-drop-target .home-primary.is-drop-unavailable,
.home-primary-actions.has-drop-target .home-secondary.is-drop-unavailable {
border: 1px solid rgba(101, 64, 43, 0.14);
}
.home-side {
display: flex;
flex-direction: column;
gap: 12px;
min-height: 0;
}
.home-card-recent {
flex: 1 1 auto;
min-height: 180px;
}
.home-card {
display: flex;
flex-direction: column;
min-height: 0;
padding: 20px;
border: 1px solid rgba(92, 56, 35, 0.08);
border-radius: 22px;
background: rgba(255, 252, 249, 0.68);
box-shadow: 0 12px 36px rgba(86, 51, 31, 0.045);
backdrop-filter: blur(16px);
}
.home-card-head {
display: flex;
2026-10-25 04:24:05 +00:00
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 10px;
color: #a08272;
}
.home-card-head > svg {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #cf7c4f;
}
2026-10-25 04:24:05 +00:00
.home-card-head h1 {
flex: 1;
min-width: 0;
2026-10-25 04:24:05 +00:00
margin: 0;
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #37221a;
font-size: var(--text-md);
font-weight: 690;
letter-spacing: -0.03em;
white-space: nowrap;
text-overflow: ellipsis;
}
2026-10-25 04:24:05 +00:00
.home-card-count {
flex: none;
padding: 3px 9px;
border-radius: 999px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #96684f;
background: rgba(242, 106, 51, 0.1);
font-size: var(--text-3xs);
font-weight: 650;
2026-10-25 04:24:05 +00:00
letter-spacing: 0.01em;
font-variant-numeric: tabular-nums;
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
.home-card-clear {
flex: none;
}
.home-empty {
display: flex;
flex: 1;
flex-direction: column;
align-items: center;
justify-content: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 12px;
margin: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #9c8172;
font-size: var(--text-2xs);
line-height: 1.55;
text-align: center;
}
.home-empty p {
margin: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
max-width: 230px;
}
.home-empty-glyph {
display: grid;
place-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 44px;
height: 44px;
border: 1px dashed rgba(150, 99, 70, 0.28);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 14px;
color: #c07a54;
background: rgba(255, 255, 255, 0.6);
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
.home-recent-search {
display: flex;
align-items: center;
gap: 8px;
flex: none;
margin-top: 12px;
padding: 0 11px;
height: 34px;
border: 1px solid rgba(96, 60, 39, 0.09);
border-radius: var(--radius-sm);
background: rgba(255, 255, 255, 0.72);
color: rgba(91, 55, 35, 0.55);
}
.home-recent-search:focus-within {
border-color: rgba(242, 106, 51, 0.42);
background: #fff;
}
.home-recent-search input {
flex: 1;
min-width: 0;
border: 0;
background: transparent;
color: #37221a;
font-size: var(--text-2xs);
outline: none;
}
.home-recent-search input::placeholder {
color: rgba(91, 55, 35, 0.45);
}
.home-recent-search button {
display: grid;
place-items: center;
width: 20px;
height: 20px;
border: 0;
border-radius: 6px;
background: rgba(91, 55, 35, 0.1);
color: #4a2b1b;
cursor: pointer;
}
.home-recent-search button:hover {
background: #f04f24;
color: #fffdf9;
}
.home-recent-list {
display: flex;
flex: 1;
flex-direction: column;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 3px;
min-height: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 14px;
/* Extra bottom room so the last row can scroll clear of the fade mask. */
padding-bottom: 22px;
overflow-y: auto;
scrollbar-width: thin;
scrollbar-color: rgba(120, 80, 58, 0.24) transparent;
/* Fade the last row so a clipped list reads as scrollable. */
mask-image: linear-gradient(180deg, #000 calc(100% - 18px), transparent);
}
.home-recent-list::-webkit-scrollbar {
width: 6px;
}
.home-recent-list::-webkit-scrollbar-thumb {
border-radius: 999px;
background: rgba(120, 80, 58, 0.22);
}
.home-recent {
position: relative;
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 13px;
cursor: grab;
animation: recent-in 0.26s cubic-bezier(0.22, 0.68, 0.32, 1) both;
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
.home-recent:active {
cursor: grabbing;
}
.home-recent:nth-child(2) {
animation-delay: 0.03s;
}
.home-recent:nth-child(3) {
animation-delay: 0.06s;
}
.home-recent:nth-child(4) {
animation-delay: 0.09s;
}
.home-recent:nth-child(5) {
animation-delay: 0.12s;
}
.home-recent:hover {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: rgba(255, 255, 255, 0.9);
box-shadow: inset 0 0 0 1px rgba(96, 60, 39, 0.05);
}
.home-recent-main {
display: flex;
flex: 1;
min-width: 0;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 11px;
width: 100%;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 7px;
border: 0;
background: transparent;
text-align: left;
cursor: pointer;
}
.home-recent-actions {
2026-10-27 10:45:32 +00:00
flex: none;
display: flex;
2026-10-27 10:45:32 +00:00
gap: 1px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 3px 5px 3px 6px;
2026-10-27 10:45:32 +00:00
border-left: 1px solid rgba(96, 60, 39, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 9px;
2026-10-27 10:45:32 +00:00
background: rgba(91, 55, 35, 0.035);
opacity: 0;
transform: translateX(4px);
transition:
opacity 0.14s ease,
transform 0.14s ease;
pointer-events: none;
}
.home-recent:hover .home-recent-actions,
.home-recent:focus-within .home-recent-actions {
opacity: 1;
transform: translateX(0);
pointer-events: auto;
}
.home-recent-actions button {
display: grid;
place-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 26px;
height: 26px;
2026-10-27 10:45:32 +00:00
border: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 7px;
color: #6a4c3d;
2026-10-27 10:45:32 +00:00
background: transparent;
cursor: pointer;
}
.home-recent-actions button:hover {
color: #fff6f1;
background: #e45c2a;
}
.home-recent-icon {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 42px;
height: 42px;
flex: none;
overflow: hidden;
display: grid;
place-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 11px;
color: #d15f31;
background: #ffeadc;
box-shadow: inset 0 0 0 1px rgba(74, 43, 27, 0.05);
}
.home-recent-icon img {
width: 100%;
height: 100%;
display: block;
object-fit: cover;
}
.home-recent-icon.video {
color: #c94d5c;
background: #ffe5e9;
}
.home-recent-icon.file,
.home-recent-icon.text {
color: #7168b8;
background: #edebff;
}
.home-recent-main > span:last-child {
min-width: 0;
display: flex;
flex-direction: column;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 3px;
}
.home-recent strong {
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #47301f;
font-size: var(--text-2xs);
font-weight: 640;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
letter-spacing: -0.01em;
white-space: nowrap;
text-overflow: ellipsis;
}
.home-recent small {
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #a2887a;
font-size: var(--text-3xs);
white-space: nowrap;
text-overflow: ellipsis;
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
/* ------------------------------------------------------------------------- */
/* Settings drawer */
/* ------------------------------------------------------------------------- */
.home-sheet-backdrop {
position: fixed;
inset: 0;
z-index: 30;
background: rgba(42, 28, 22, 0.18);
backdrop-filter: blur(2px);
animation: home-fade 0.16s ease-out;
}
.home-settings {
position: fixed;
z-index: 40;
top: 0;
right: 0;
bottom: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: min(436px, 92vw);
2026-10-25 04:24:05 +00:00
display: flex;
flex-direction: column;
overflow: hidden;
padding: 0;
border-left: 1px solid rgba(88, 51, 31, 0.1);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: #fffbf7;
box-shadow: -24px 0 70px rgba(66, 38, 23, 0.16);
transform: translateX(102%);
visibility: hidden;
transition:
transform 0.22s ease,
visibility 0.22s;
}
.home-settings.is-open {
transform: translateX(0);
visibility: visible;
}
.home-settings-head {
2026-10-25 04:24:05 +00:00
position: relative;
z-index: 2;
display: flex;
2026-10-25 04:24:05 +00:00
flex: none;
align-items: center;
2026-10-25 04:24:05 +00:00
justify-content: flex-start;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 12px;
padding: 20px 20px 16px;
2026-10-25 04:24:05 +00:00
border-bottom: 1px solid rgba(91, 55, 35, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: rgba(255, 251, 246, 0.96);
2026-10-25 04:24:05 +00:00
backdrop-filter: blur(16px);
}
2026-10-25 04:24:05 +00:00
.home-settings-close {
flex: none;
}
2026-10-25 04:24:05 +00:00
.home-settings-heading {
min-width: 0;
display: flex;
flex-direction: column;
}
.home-settings-heading h2 {
overflow: hidden;
margin: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #34201a;
font-size: var(--text-xl);
font-weight: 700;
letter-spacing: -0.035em;
2026-10-25 04:24:05 +00:00
white-space: nowrap;
text-overflow: ellipsis;
}
.home-settings-tabs {
display: flex;
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 4px;
padding: 10px 14px 0;
2026-10-25 04:24:05 +00:00
border-bottom: 1px solid rgba(91, 55, 35, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: #fffbf7;
overflow-x: auto;
scrollbar-width: none;
}
.home-settings-tabs::-webkit-scrollbar {
display: none;
2026-10-25 04:24:05 +00:00
}
.home-settings-tab {
position: relative;
display: inline-flex;
flex: 0 1 auto;
align-items: center;
justify-content: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 7px;
min-width: 84px;
height: 44px;
padding: 0 10px;
2026-10-25 04:24:05 +00:00
border: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 10px 10px 0 0;
color: #8b6d5d;
2026-10-25 04:24:05 +00:00
background: transparent;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 650;
white-space: nowrap;
2026-10-25 04:24:05 +00:00
cursor: pointer;
transition:
color 0.16s ease,
background 0.16s ease;
}
.home-settings-tab:hover {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #55382a;
background: rgba(242, 106, 51, 0.06);
2026-10-25 04:24:05 +00:00
}
.home-settings-tab.is-active {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #452a1d;
background: rgba(242, 106, 51, 0.09);
2026-10-25 04:24:05 +00:00
}
.home-settings-tab.is-active::after {
content: "";
position: absolute;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
right: 8px;
2026-10-25 04:24:05 +00:00
bottom: -1px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
left: 8px;
height: 2.5px;
border-radius: 3px 3px 0 0;
2026-10-25 04:24:05 +00:00
background: #e45c2a;
}
.home-settings-body {
flex: 1;
min-height: 0;
overflow-y: auto;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 0 24px 40px;
2026-10-25 04:24:05 +00:00
}
.home-settings-panel {
min-height: 100%;
}
.home-settings-panel > .home-settings-section:first-child {
border-top: 0;
}
.home-settings-section {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 20px 0;
border-top: 1px solid rgba(91, 55, 35, 0.08);
}
.home-section-title {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
color: #43291d;
font-size: var(--text-sm);
font-weight: 690;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
letter-spacing: -0.02em;
}
.home-section-title > svg {
flex: none;
color: #cf7c4f;
}
.home-segment {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 3px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 12px;
padding: 3px;
border: 1px solid rgba(96, 59, 38, 0.08);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: var(--radius-sm);
background: rgba(111, 73, 51, 0.055);
}
.home-segment button {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 34px;
border: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-radius: 8px;
color: #7f6355;
background: transparent;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 630;
cursor: pointer;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
transition:
color 0.14s ease,
background 0.14s ease,
box-shadow 0.14s ease;
}
.home-segment button:hover {
color: #4c3123;
}
.home-segment button.is-active {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #40281c;
background: #fff;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
box-shadow: 0 2px 7px rgba(74, 43, 27, 0.1);
}
.settings-output {
margin-top: 12px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 13px;
border: 1px solid rgba(100, 61, 39, 0.09);
border-radius: var(--radius-md);
background: rgba(255, 255, 255, 0.62);
}
.settings-output-head {
display: flex;
align-items: center;
justify-content: space-between;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 12px;
color: #66493b;
font-size: var(--text-2xs);
font-weight: 650;
}
.settings-link {
padding: 0;
border: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #bf5527;
background: transparent;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 650;
cursor: pointer;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.settings-link:hover:not(:disabled) {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #9c401a;
}
.settings-path {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
margin-top: 10px;
padding: 9px 11px;
border-radius: 9px;
color: #74584a;
background: rgba(106, 69, 47, 0.055);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
}
.settings-path svg {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #b3734c;
}
.settings-path span {
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.settings-output-actions {
display: flex;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
margin-top: 10px;
}
.settings-output-actions > * {
flex: 1;
}
.settings-small-button,
.settings-wide-button,
.home-permission-row button {
display: inline-flex;
align-items: center;
justify-content: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 6px;
height: 32px;
padding: 0 12px;
border: 1px solid rgba(99, 61, 39, 0.11);
border-radius: 9px;
color: #5b4132;
background: #fff;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 640;
cursor: pointer;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
transition:
border-color 0.16s ease,
background 0.16s ease,
color 0.16s ease;
}
.settings-small-button:hover,
.settings-wide-button:hover,
.home-permission-row button:hover {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(228, 92, 42, 0.26);
color: #3f281e;
}
.settings-wide-button {
width: 100%;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 36px;
margin-top: 12px;
}
.home-toggle-row {
display: flex;
align-items: center;
justify-content: space-between;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 18px;
min-height: 34px;
cursor: pointer;
}
2026-10-25 04:24:05 +00:00
/* A rule between two switches that share one section. */
.home-toggle-divider {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 14px;
padding-top: 14px;
2026-10-25 04:24:05 +00:00
border-top: 1px solid rgba(91, 55, 35, 0.08);
}
.home-toggle-row strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #43291d;
font-size: var(--text-2xs);
font-weight: 640;
}
.home-toggle {
position: relative;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 42px;
height: 24px;
flex: none;
padding: 0;
border: 0;
border-radius: 999px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: rgba(104, 69, 48, 0.2);
cursor: pointer;
transition: background 0.16s ease;
}
.home-toggle span {
position: absolute;
top: 3px;
left: 3px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
width: 18px;
height: 18px;
border-radius: 50%;
background: #fff;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
box-shadow: 0 1px 3px rgba(50, 29, 18, 0.22);
transition: transform 0.16s ease;
}
.home-toggle.is-on {
background: #f06a37;
}
.home-toggle.is-on span {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
transform: translateX(18px);
}
.home-checks {
display: flex;
flex-direction: column;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 6px;
margin-top: 12px;
}
.home-check {
display: flex;
align-items: flex-start;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 9px;
padding: 10px 12px;
border-radius: var(--radius-sm);
font-size: var(--text-2xs);
line-height: 1.45;
}
.home-check.is-ok {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #2c6a4a;
background: #edf8f1;
}
.home-check.is-bad {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #9c3d2f;
background: #fff0ed;
}
.home-check svg {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 2px;
}
.home-check span {
display: flex;
flex-direction: column;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 3px;
min-width: 0;
}
.home-check strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 690;
}
.home-check small {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
line-height: 1.45;
opacity: 0.92;
}
2026-10-25 04:24:05 +00:00
.runtime-section-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
}
2026-10-25 04:24:05 +00:00
.runtime-refresh {
display: inline-flex;
flex: none;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 5px;
}
fix(drop): let Windows finish a row dropped on a button, and spend every button alike A row dragged from Recent onto any of the three buttons did nothing on Windows, and reported itself as a refusal. Both delivery paths can stay silent on that platform, so the gesture now ends in `dragEnd`, which always arrives and carries a point to hit-test. The two paths are silent for two separate reasons. A Recent row is a real file drag, and WebView2 registers its own OLE drop target on the window, so the DOM drop never reaches the page; that target then reads only `CF_HDROP`, which an in-page drag does not carry, so `enter_is_valid` stays false and the native `over`/`drop`/`leave` are withheld too. `landed` keeps the fallback an execution rather than a second one, and a release outside the window runs nothing, because the hit-test has slack around every button and the row was meant for Explorer. An idle ring also stops getting in the way. It is borderless and always on top, so one left open from a previous drop sits over the buttons; macOS passes mouse events through its transparent pixels and Windows hands the gesture to whichever HWND is under the pointer. Starting a row drag now puts such a ring aside, while a ring owned by an in-flight Shift-drag gesture keeps waiting for the release that decides its fate. The availability rule stops being OCR's alone. `lib/dropCapabilities` answers one question - can this button serve these files - and the button's spent state, its candidacy while a drag is in flight, and the drop itself all ask it, so Convert spends for a `.key` the way OCR spends for a PDF, on both platforms, whichever drag source carried the file. Tools never spends: its ring ends in Open, Reveal and Send. An unknown payload is not a refusal, because spending on an empty path list would disable a gesture that works. Two other reports this round were not about the drag at all: - A file received over the LAN now reveals itself only when "show results in Finder" is on, the way a finished conversion already behaves, and a batch reveals once at its last file rather than once per file. - Missing runtime components install as one request. Installs run one after another because the package managers hold a single lock, and one package answering two rows - Poppler for both PDF rows on Windows - is installed once. The panel re-reads the machine afterwards either way, since a batch that stopped at its first failure may have landed everything before it.
2026-11-06 15:13:41 +00:00
.runtime-head-actions {
display: flex;
flex: none;
align-items: center;
gap: 8px;
}
.runtime-install-all {
margin-top: 0;
}
2026-10-25 04:24:05 +00:00
.runtime-refresh:disabled {
cursor: default;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
2026-10-25 04:24:05 +00:00
}
.runtime-summary {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin: 10px 0 0;
color: #8f7365;
font-size: var(--text-2xs);
line-height: 1.6;
2026-10-25 04:24:05 +00:00
}
.runtime-loading,
.runtime-error {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 9px;
margin-top: 12px;
padding: 11px 12px;
border-radius: var(--radius-sm);
font-size: var(--text-2xs);
line-height: 1.5;
2026-10-25 04:24:05 +00:00
}
.runtime-loading {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #7b5e4f;
2026-10-25 04:24:05 +00:00
background: rgba(111, 73, 51, 0.055);
}
.runtime-error {
flex-wrap: wrap;
align-items: flex-start;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #963a2d;
2026-10-25 04:24:05 +00:00
background: #fff0ed;
}
.runtime-error > span {
flex: 1;
min-width: 180px;
white-space: pre-wrap;
}
.runtime-error-link {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 28px;
padding: 0 10px;
border: 1px solid rgba(158, 61, 48, 0.2);
border-radius: 8px;
2026-10-25 04:24:05 +00:00
color: #8a3e32;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: rgba(255, 255, 255, 0.75);
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 680;
cursor: pointer;
}
.runtime-error-link:hover {
background: #fff;
}
.runtime-group {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 16px;
2026-10-25 04:24:05 +00:00
}
.runtime-group-title {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-bottom: 7px;
color: #9c7a66;
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 760;
letter-spacing: 0.08em;
text-transform: uppercase;
}
.runtime-component {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 12px 13px;
border: 1px solid rgba(96, 59, 38, 0.08);
border-radius: var(--radius-sm);
background: rgba(255, 255, 255, 0.62);
2026-10-25 04:24:05 +00:00
}
.runtime-component + .runtime-component {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 7px;
2026-10-25 04:24:05 +00:00
}
.runtime-component.is-missing {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(173, 65, 49, 0.14);
background: rgba(255, 244, 241, 0.75);
2026-10-25 04:24:05 +00:00
}
.runtime-component-head {
display: flex;
align-items: center;
justify-content: space-between;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 10px;
2026-10-25 04:24:05 +00:00
}
.runtime-component-head strong {
min-width: 0;
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #43291d;
font-size: var(--text-2xs);
font-weight: 690;
2026-10-25 04:24:05 +00:00
white-space: nowrap;
text-overflow: ellipsis;
}
.runtime-source {
flex: none;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 3px 7px;
2026-10-25 04:24:05 +00:00
border-radius: 999px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 720;
letter-spacing: 0.03em;
}
.runtime-source.is-bundled {
color: #a94d28;
background: #ffeadc;
}
.runtime-source.is-system {
color: #39715b;
background: #e8f4ee;
}
.runtime-source.is-external {
color: #556da0;
background: #eaf0fb;
}
.runtime-component-meta {
display: flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 9px;
2026-10-25 04:24:05 +00:00
min-width: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 7px;
2026-10-25 04:24:05 +00:00
}
.runtime-status {
display: inline-flex;
flex: none;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 4px;
color: #2c6a4a;
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 680;
}
.runtime-component.is-missing .runtime-status {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #9c3d2f;
2026-10-25 04:24:05 +00:00
}
.runtime-version {
min-width: 0;
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
color: #93766a;
font-size: var(--text-3xs);
font-variant-numeric: tabular-nums;
2026-10-25 04:24:05 +00:00
white-space: nowrap;
text-overflow: ellipsis;
}
.runtime-path {
display: block;
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 7px;
padding: 6px 8px;
border-radius: 7px;
color: #74584b;
2026-10-25 04:24:05 +00:00
background: rgba(106, 69, 47, 0.05);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-family: "SFMono-Regular", "SF Mono", Consolas, monospace;
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
white-space: nowrap;
text-overflow: ellipsis;
}
.runtime-install {
display: inline-flex;
align-items: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
justify-content: center;
gap: 6px;
height: 32px;
margin-top: 10px;
padding: 0 12px;
border: 1px solid rgba(190, 83, 42, 0.2);
border-radius: 9px;
2026-10-25 04:24:05 +00:00
color: #a84c29;
background: #fff1e7;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 700;
cursor: pointer;
}
.runtime-install:hover:not(:disabled) {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
border-color: rgba(190, 83, 42, 0.34);
2026-10-25 04:24:05 +00:00
background: #ffe9db;
}
.runtime-install:disabled {
cursor: default;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
2026-10-25 04:24:05 +00:00
}
.runtime-bundled {
display: block;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 7px;
color: #93766a;
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
}
.home-permission-row {
display: grid;
grid-template-columns: 1fr 1fr;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
gap: 8px;
margin-top: 12px;
2026-10-25 04:24:05 +00:00
}
.home-permission-row button:nth-child(3) {
grid-column: span 2;
}
@keyframes home-fade {
from {
opacity: 0;
}
}
@keyframes recent-in {
from {
opacity: 0;
transform: translateY(5px);
}
}
@keyframes home-rise {
from {
opacity: 0;
transform: translateY(9px);
}
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
@media (max-height: 680px) {
2026-10-25 04:24:05 +00:00
.home-drop {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
padding: 22px 30px;
2026-10-25 04:24:05 +00:00
}
.home-drop-art {
height: 86px;
margin-bottom: 14px;
transform: scale(0.84);
}
.home-drop h1 {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-xl);
}
.home-primary,
.home-secondary {
height: 42px;
2026-10-25 04:24:05 +00:00
}
.home-primary-actions {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
margin-top: 20px;
2026-10-25 04:24:05 +00:00
}
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
.home-drop-hint {
margin-top: 12px;
}
}
@media (max-width: 1040px) {
.home-primary,
.home-secondary {
height: 42px;
padding: 0 15px;
font-size: var(--text-sm);
}
2026-10-25 04:24:05 +00:00
}
@media (max-width: 920px) {
.home-main {
grid-template-columns: minmax(0, 1fr);
overflow-y: auto;
}
/* Stacked: let the page scroll instead of squeezing the drop panel. */
.home-drop {
min-height: 400px;
}
.home-side {
flex-direction: column;
}
.home-card-recent {
min-height: 260px;
}
}
@media (prefers-reduced-motion: reduce) {
.home-recent {
animation: none;
}
}
/* ------------------------------------------------------------------------- */
/* LAN share (AirDrop-style) */
/* ------------------------------------------------------------------------- */
.share-backdrop {
position: fixed;
inset: 0;
z-index: 60;
background: rgba(40, 25, 18, 0.26);
backdrop-filter: blur(3px);
animation: home-fade 0.18s ease-out;
}
.share-panel {
position: fixed;
left: 50%;
top: 50%;
z-index: 61;
display: flex;
width: min(760px, 94vw);
max-height: min(760px, 90vh);
flex-direction: column;
gap: 12px;
padding: 20px 22px 16px;
overflow: hidden;
border: 1px solid rgba(92, 56, 35, 0.1);
border-radius: 24px;
background: linear-gradient(168deg, #fffaf5, #fdf1e6 62%, #fbeadf);
box-shadow:
0 34px 90px rgba(62, 33, 18, 0.28),
inset 0 1px 0 rgba(255, 255, 255, 0.7);
transform: translate(-50%, -50%);
animation: share-in 0.24s cubic-bezier(0.22, 0.68, 0.32, 1) both;
}
.share-panel::before {
content: "";
position: absolute;
left: 50%;
top: -150px;
width: 420px;
height: 300px;
transform: translateX(-50%);
border-radius: 50%;
background: radial-gradient(circle, rgba(255, 164, 105, 0.28), transparent 70%);
pointer-events: none;
}
@keyframes share-in {
from {
opacity: 0;
transform: translate(-50%, -46%) scale(0.97);
}
}
.share-head {
position: relative;
display: flex;
align-items: center;
gap: 11px;
}
.share-head-glyph {
display: grid;
place-items: center;
width: 34px;
height: 34px;
flex: none;
border-radius: 11px;
color: #fff6f1;
background: linear-gradient(140deg, #ff9459, #ea5423);
box-shadow: 0 8px 18px rgba(228, 83, 39, 0.28);
}
.share-head-copy {
flex: 1;
min-width: 0;
}
.share-head-copy h2 {
margin: 0;
color: #35211a;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-md);
2026-10-25 04:24:05 +00:00
font-weight: 690;
letter-spacing: -0.02em;
}
.share-head-copy p {
margin: 2px 0 0;
overflow: hidden;
color: #9a7b69;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
white-space: nowrap;
text-overflow: ellipsis;
}
.share-files {
display: flex;
flex-direction: column;
gap: 7px;
min-height: 0;
padding: 10px 11px 9px;
border: 1px solid rgba(96, 60, 39, 0.09);
border-radius: 14px;
background: rgba(255, 255, 255, 0.66);
}
.share-files-head {
display: flex;
align-items: center;
gap: 8px;
min-height: 18px;
}
.share-files-head > strong {
color: #4a3125;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 680;
}
.share-files-head > span {
color: #a48778;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-variant-numeric: tabular-nums;
}
.share-select-all {
display: inline-flex;
align-items: center;
gap: 5px;
margin-left: auto;
color: #876b5b;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 620;
cursor: pointer;
}
.share-file-list {
display: grid;
max-height: 118px;
grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
gap: 5px;
overflow-y: auto;
padding-right: 2px;
scrollbar-width: thin;
}
.share-file-row,
.share-select-all {
position: relative;
user-select: none;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
/* "Select all" follows the rows it selects: while a transfer locks the panel the
label stayed bright with nothing behind it left to click. */
.share-select-all:has(input:disabled) {
opacity: var(--dimmed);
cursor: default;
}
2026-10-25 04:24:05 +00:00
.share-file-row {
display: flex;
align-items: center;
gap: 6px;
min-width: 0;
padding: 7px 8px;
border: 1px solid rgba(96, 60, 39, 0.075);
border-radius: 9px;
color: #785b4c;
background: rgba(255, 250, 245, 0.7);
cursor: grab;
transition:
border-color 0.14s ease,
background 0.14s ease;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
.share-file-row:hover:not(:has(input:disabled)) {
2026-10-25 04:24:05 +00:00
border-color: rgba(228, 92, 42, 0.2);
background: #fff;
}
.share-file-row:active {
cursor: grabbing;
}
.share-file-row.is-checked {
border-color: rgba(228, 92, 42, 0.23);
background: #fff;
}
.share-file-row input,
.share-select-all input {
position: absolute;
width: 1px;
height: 1px;
opacity: 0;
pointer-events: none;
}
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
/* The checkbox carries the state, so the row has to show it. Ignored on a webview
without `:has`, which leaves the row looking live as it did before. */
.share-file-row:has(input:disabled) {
opacity: var(--dimmed);
cursor: default;
}
/* The real checkbox is a hidden 1px box, so the ring belongs on the row it names. */
.share-file-row input,
.share-select-all input {
outline: none;
}
.share-file-row:focus-within {
border-color: rgba(242, 106, 51, 0.55);
box-shadow: 0 0 0 3px rgba(242, 106, 51, 0.14);
}
/* "Select all" has no border of its own, so its ring is drawn as a shadow. */
.share-select-all:focus-within {
box-shadow: 0 0 0 3px rgba(242, 106, 51, 0.14);
}
2026-10-25 04:24:05 +00:00
.share-checkmark {
display: grid;
place-items: center;
width: 15px;
height: 15px;
flex: none;
border: 1px solid rgba(104, 68, 47, 0.24);
border-radius: 4px;
color: #fff;
background: #fff;
}
.share-file-row.is-checked .share-checkmark,
.share-select-all input:checked + .share-checkmark {
border-color: #e45c2a;
background: #e45c2a;
}
.share-file-row > svg:not(.share-file-grip) {
flex: none;
color: #b56f4c;
}
.share-file-copy {
display: flex;
min-width: 0;
flex: 1;
flex-direction: column;
gap: 1px;
}
.share-file-copy strong,
.share-file-copy small {
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.share-file-copy strong {
color: #4a3125;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 630;
}
.share-file-copy small {
color: #a78d7f;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
}
.share-file-grip {
flex: none;
color: #c0a99b;
}
.share-reshow {
display: inline-flex;
flex: none;
align-items: center;
gap: 5px;
padding: 4px 9px;
border: 1px solid rgba(242, 106, 51, 0.22);
border-radius: 999px;
color: #c1521f;
background: rgba(255, 240, 231, 0.8);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 660;
cursor: pointer;
}
.share-reshow:hover:not(:disabled) {
color: #fff6f1;
background: #e45c2a;
}
.share-reshow:disabled {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
2026-10-25 04:24:05 +00:00
cursor: default;
}
.share-grid {
position: relative;
display: grid;
flex: 1;
grid-template-columns: repeat(auto-fill, minmax(132px, 1fr));
gap: 9px;
min-height: 190px;
max-height: 390px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
align-content: start;
2026-10-25 04:24:05 +00:00
overflow-y: auto;
padding: 2px;
scrollbar-width: thin;
}
.share-peer {
display: flex;
align-items: center;
flex-direction: column;
gap: 7px;
padding: 14px 8px 12px;
border: 1px solid transparent;
border-radius: 16px;
color: #4a3125;
background: rgba(255, 255, 255, 0.6);
cursor: pointer;
animation: share-peer-in 0.26s cubic-bezier(0.22, 0.68, 0.32, 1) both;
transition:
transform 0.14s ease,
border-color 0.14s ease,
background 0.14s ease,
box-shadow 0.14s ease;
}
.share-peer:hover:not(:disabled) {
border-color: rgba(242, 106, 51, 0.3);
background: #fff;
box-shadow: 0 12px 26px rgba(120, 66, 34, 0.12);
transform: translateY(-2px);
}
.share-peer:disabled {
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
2026-10-25 04:24:05 +00:00
cursor: default;
}
.share-peer.is-active {
border-color: rgba(242, 106, 51, 0.55);
background: #fff;
box-shadow: 0 0 0 4px rgba(242, 106, 51, 0.14);
}
.share-peer.is-drop-target {
border-color: rgba(242, 106, 51, 0.7);
background: #fff8f2;
box-shadow:
0 0 0 4px rgba(242, 106, 51, 0.16),
0 16px 32px rgba(120, 66, 34, 0.14);
transform: translateY(-2px);
}
.share-peer-avatar {
display: grid;
place-items: center;
width: 48px;
height: 48px;
border-radius: 50%;
color: #cf5a28;
background: radial-gradient(circle at 32% 28%, #fff3e9, #ffd9c2);
box-shadow:
inset 0 0 0 1px rgba(120, 66, 34, 0.08),
0 6px 14px rgba(120, 66, 34, 0.1);
}
.share-peer-name {
max-width: 100%;
overflow: hidden;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 650;
white-space: nowrap;
text-overflow: ellipsis;
}
2026-10-25 04:24:05 +00:00
.share-peer-meta {
margin-top: -4px;
color: #a78d7f;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
letter-spacing: 0.04em;
}
@keyframes share-peer-in {
from {
opacity: 0;
2026-10-25 04:24:05 +00:00
transform: translateY(7px) scale(0.96);
}
}
2026-10-25 04:24:05 +00:00
@media (prefers-reduced-motion: reduce) {
.share-panel,
.share-peer {
animation: none;
}
}
.share-empty {
position: relative;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 8px;
min-height: 186px;
padding: 18px;
border: 1px dashed rgba(150, 99, 70, 0.24);
border-radius: 16px;
text-align: center;
}
.share-empty-glyph {
display: grid;
place-items: center;
width: 42px;
height: 42px;
border-radius: 14px;
color: #c07a54;
background: rgba(255, 255, 255, 0.68);
}
.share-empty strong {
color: #4d3327;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
2026-10-25 04:24:05 +00:00
font-weight: 660;
}
.share-empty p {
max-width: 280px;
margin: 0;
color: #a08578;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
line-height: 1.5;
}
.share-progress {
position: relative;
display: flex;
flex-direction: column;
gap: 6px;
padding: 10px 12px;
border: 1px solid rgba(96, 60, 39, 0.09);
border-radius: 12px;
background: rgba(255, 255, 255, 0.72);
}
.share-progress-head {
display: flex;
align-items: baseline;
justify-content: space-between;
gap: 10px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 620;
}
.share-progress-head span {
overflow: hidden;
color: #4a3125;
white-space: nowrap;
text-overflow: ellipsis;
}
.share-progress-head small {
flex: none;
color: #a78d7f;
font-variant-numeric: tabular-nums;
}
.share-bar {
height: 5px;
overflow: hidden;
border-radius: 999px;
background: rgba(120, 74, 45, 0.12);
}
.share-bar span {
display: block;
height: 100%;
border-radius: 999px;
background: linear-gradient(90deg, #f9a05f, #e4531f);
transition: width 0.16s linear;
}
/* No byte counts exist while the peer decides, so the bar sweeps instead. */
.share-bar.is-indeterminate {
position: relative;
}
.share-bar.is-indeterminate span {
position: absolute;
inset: 0 auto 0 0;
width: 38%;
transition: none;
animation: share-sweep 1.15s cubic-bezier(0.5, 0, 0.5, 1) infinite;
}
@keyframes share-sweep {
from {
2026-10-25 04:24:05 +00:00
transform: translateX(-105%);
}
to {
transform: translateX(280%);
}
}
2026-10-25 04:24:05 +00:00
.share-progress-wait {
display: inline-flex;
align-items: center;
gap: 6px;
min-width: 0;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.share-error {
display: flex;
align-items: center;
gap: 6px;
color: #b8442a;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 620;
}
.share-foot {
display: flex;
align-items: center;
justify-content: space-between;
gap: 10px;
border-top: 1px solid rgba(96, 60, 39, 0.08);
padding-top: 10px;
color: #a08578;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
}
.share-foot kbd {
flex: none;
padding: 2px 6px;
border: 1px solid rgba(104, 68, 47, 0.12);
border-radius: 5px;
color: #7c5d4d;
background: rgba(255, 255, 255, 0.8);
font-family: inherit;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 640;
}
/* ------------------------------------------------------------------------- */
/* Incoming file notice (receiver side of a LAN share) */
/* ------------------------------------------------------------------------- */
.share-notice {
position: fixed;
inset: 6px;
display: flex;
flex-direction: column;
gap: 9px;
padding: 13px 14px 11px;
overflow: hidden;
border: 1px solid rgba(92, 56, 35, 0.12);
border-radius: 18px;
background: linear-gradient(165deg, #fffbf7, #fdf0e5 70%, #fbe6d9);
box-shadow:
0 22px 54px rgba(58, 31, 16, 0.24),
inset 0 1px 0 rgba(255, 255, 255, 0.72);
animation: share-notice-in 0.22s cubic-bezier(0.22, 0.68, 0.32, 1) both;
}
@keyframes share-notice-in {
from {
opacity: 0;
2026-10-25 04:24:05 +00:00
transform: translateY(10px) scale(0.98);
}
}
2026-10-25 04:24:05 +00:00
.share-notice-head {
display: flex;
align-items: center;
gap: 8px;
min-width: 0;
}
2026-10-25 04:24:05 +00:00
.share-notice-glyph {
display: grid;
place-items: center;
width: 26px;
height: 26px;
flex: none;
border-radius: 9px;
color: #fff6f1;
background: linear-gradient(140deg, #ff9459, #ea5423);
box-shadow: 0 6px 14px rgba(228, 83, 39, 0.26);
}
2026-10-25 04:24:05 +00:00
.share-notice-kicker {
flex: 1;
min-width: 0;
overflow: hidden;
color: #7d5c4b;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 640;
white-space: nowrap;
text-overflow: ellipsis;
}
2026-10-25 04:24:05 +00:00
.share-notice-count {
flex: none;
padding: 2px 7px;
border-radius: 999px;
color: #9a705c;
background: rgba(242, 106, 51, 0.1);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-weight: 680;
font-variant-numeric: tabular-nums;
}
2026-10-25 04:24:05 +00:00
.share-notice-count.is-low {
color: #b8442a;
background: rgba(228, 83, 39, 0.16);
}
2026-10-25 04:24:05 +00:00
.share-notice-file {
display: flex;
flex-direction: column;
gap: 2px;
padding: 9px 11px;
border: 1px solid rgba(96, 60, 39, 0.09);
border-radius: 12px;
background: rgba(255, 255, 255, 0.72);
}
2026-10-25 04:24:05 +00:00
.share-notice-file strong {
overflow: hidden;
color: #45302a;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
2026-10-25 04:24:05 +00:00
font-weight: 660;
white-space: nowrap;
text-overflow: ellipsis;
}
2026-10-25 04:24:05 +00:00
.share-notice-file small {
color: #a08578;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
2026-10-25 04:24:05 +00:00
font-variant-numeric: tabular-nums;
}
2026-10-25 04:24:05 +00:00
.share-notice-actions {
display: flex;
gap: 8px;
}
.share-notice-actions button {
display: inline-flex;
flex: 1;
align-items: center;
justify-content: center;
gap: 6px;
padding: 8px 10px;
border-radius: 11px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-xs);
2026-10-25 04:24:05 +00:00
font-weight: 670;
cursor: pointer;
transition:
transform 0.14s ease,
background 0.14s ease,
box-shadow 0.14s ease;
}
.share-notice-actions button:hover {
transform: translateY(-1px);
}
.share-notice-accept {
border: 0;
color: #fff7f2;
background: linear-gradient(135deg, #ff8a4c, #e4531f);
box-shadow: 0 10px 22px rgba(228, 83, 39, 0.3);
}
.share-notice-decline {
border: 1px solid rgba(101, 64, 43, 0.14);
color: #6b4c3d;
background: rgba(255, 255, 255, 0.78);
}
.share-notice-decline:hover {
border-color: rgba(242, 106, 51, 0.3);
background: #fff;
}
/* The countdown doubles as the deadline, so it is drawn rather than only counted. */
.share-notice-bar {
height: 3px;
overflow: hidden;
border-radius: 999px;
background: rgba(120, 74, 45, 0.12);
}
.share-notice-bar span {
display: block;
height: 100%;
border-radius: 999px;
background: linear-gradient(90deg, rgba(249, 160, 95, 0.85), rgba(228, 83, 31, 0.85));
transition: width 0.25s linear;
}
@media (prefers-reduced-motion: reduce) {
2026-10-25 04:24:05 +00:00
.share-notice {
animation: none;
}
}
/* ------------------------------------------------------------------------- */
/* Pinned screenshot */
/* ------------------------------------------------------------------------- */
.pin-shell {
position: fixed;
inset: 0;
overflow: hidden;
border-radius: 12px;
2026-10-25 04:24:05 +00:00
background: #201b18;
}
.pin-surface {
width: 100%;
height: 100%;
overflow: hidden;
border: 1px solid rgba(255, 255, 255, 0.24);
border-radius: 12px;
2026-10-25 04:24:05 +00:00
background: #201b18;
}
.pin-surface img {
width: 100%;
height: 100%;
display: block;
object-fit: contain;
}
.pin-loading {
width: 100%;
height: 100%;
background: linear-gradient(120deg, rgba(255, 255, 255, 0.1), rgba(255, 255, 255, 0.03));
}
.pin-actions {
position: absolute;
top: 8px;
right: 8px;
display: flex;
gap: 5px;
opacity: 0;
transition: opacity 0.15s ease;
}
.pin-shell:hover .pin-actions {
opacity: 1;
}
.pin-actions button {
width: 26px;
height: 26px;
display: grid;
place-items: center;
border: 0;
border-radius: 8px;
color: white;
background: rgba(24, 20, 18, 0.72);
box-shadow: 0 6px 16px rgba(0, 0, 0, 0.24);
backdrop-filter: blur(10px);
cursor: pointer;
}
.pin-actions button:hover {
background: rgba(240, 79, 36, 0.92);
}
.pin-error {
position: fixed;
inset: 0;
display: grid;
place-items: center;
padding: 18px;
border-radius: 12px;
color: #fff5ed;
background: rgba(32, 24, 21, 0.88);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-2xs);
text-align: center;
}
2026-10-25 04:24:05 +00:00
/* The radial window is transparent, so a blurred backdrop composites badly there. */
body[data-view="radial"] .share-backdrop {
background: rgba(40, 25, 18, 0.16);
backdrop-filter: none;
}
/* Updates: git release branch, hash-verified download. */
/* The two header lines above the Updates heading: the host and the feed. The
host line also carries the artifact the feed will install, so an "no artifact
for this platform" answer below explains itself. */
.update-meta {
display: grid;
gap: 6px;
padding-bottom: 12px;
margin-bottom: 14px;
border-bottom: 1px solid rgba(140, 92, 62, 0.12);
}
.update-meta-line {
display: flex;
align-items: center;
flex-wrap: wrap;
gap: 7px;
color: #6b4f42;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
}
.update-meta-line code {
flex: 1 1 240px;
min-width: 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
padding: 4px 8px;
border-radius: 8px;
background: rgba(240, 79, 36, 0.06);
color: rgba(60, 34, 20, 0.8);
word-break: break-all;
}
.update-meta-label {
color: #9c7e6d;
font-weight: 600;
}
.update-trust {
display: inline-flex;
align-items: center;
gap: 5px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
line-height: 1.45;
color: rgba(91, 55, 35, 0.62);
}
.update-trust.is-signed {
color: rgba(28, 110, 74, 0.86);
}
.update-status-row {
display: flex;
align-items: center;
gap: 10px;
flex-wrap: wrap;
}
.update-arrow {
display: inline-flex;
align-items: center;
gap: 6px;
color: rgba(91, 55, 35, 0.62);
}
.update-new {
display: inline-flex;
align-items: center;
gap: 4px;
padding: 2px 8px;
border-radius: 999px;
background: rgba(26, 162, 96, 0.12);
color: #14794a;
font-weight: 600;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
}
.update-arrow small {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
}
.update-state {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
font-weight: 600;
color: rgba(91, 55, 35, 0.6);
}
.update-state.is-available,
.update-state.is-ready {
color: #14794a;
}
.update-state.is-error,
.update-state.is-unavailable {
color: #b4342a;
}
.update-notes {
margin: 10px 0 0;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
line-height: 1.55;
color: rgba(60, 34, 20, 0.74);
white-space: pre-wrap;
}
.update-artifact {
display: flex;
align-items: center;
gap: 7px;
margin-top: 12px;
padding: 8px 10px;
border-radius: 10px;
background: rgba(255, 255, 255, 0.7);
border: 1px solid rgba(91, 55, 35, 0.1);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
}
.update-artifact-name {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
flex: 1;
}
.update-artifact-size {
color: rgba(91, 55, 35, 0.6);
font-variant-numeric: tabular-nums;
}
.update-progress {
position: relative;
height: 22px;
margin-top: 10px;
border-radius: 999px;
overflow: hidden;
background: rgba(91, 55, 35, 0.08);
}
.update-progress-fill {
position: absolute;
inset: 0 auto 0 0;
background: linear-gradient(90deg, rgba(240, 79, 36, 0.75), rgba(26, 162, 96, 0.75));
transition: width 0.25s ease;
}
.update-progress span {
position: relative;
display: block;
text-align: center;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
line-height: 22px;
font-variant-numeric: tabular-nums;
}
.update-hash {
display: inline-flex;
align-items: center;
gap: 5px;
margin-top: 10px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
color: rgba(60, 34, 20, 0.66);
word-break: break-all;
}
.runtime-error.is-ok {
border-color: rgba(26, 162, 96, 0.4);
background: rgba(26, 162, 96, 0.08);
color: #12603c;
}
.update-actions {
display: flex;
align-items: center;
gap: 8px;
margin-top: 12px;
}
/* The two ways an update can end. They sit in a panel whose own text is 12px, so
they are sized to that rather than to the Runtime tab's 8.5px rows they were
borrowed from, and both take the same box so the pair reads as a choice
instead of a button with a stray link beside it. */
.update-action {
display: inline-flex;
align-items: center;
justify-content: center;
gap: 6px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
height: 34px;
padding: 0 14px;
border: 1px solid rgba(91, 55, 35, 0.14);
border-radius: 9px;
color: #5f4437;
background: rgba(255, 255, 255, 0.72);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-xs);
font-weight: 640;
cursor: pointer;
transition:
border-color 0.16s ease,
background 0.16s ease,
box-shadow 0.16s ease;
}
.update-action:hover:not(:disabled) {
border-color: rgba(242, 106, 51, 0.26);
background: #fff;
box-shadow: 0 6px 14px rgba(96, 56, 33, 0.1);
}
.update-action:disabled {
cursor: default;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
opacity: var(--dimmed);
}
.update-action.is-commit {
border-color: transparent;
color: #fff8f2;
background: linear-gradient(135deg, #ff8248, #eb5427);
box-shadow: 0 6px 16px rgba(228, 83, 39, 0.24);
font-weight: 700;
}
.update-action.is-commit:hover:not(:disabled) {
border-color: transparent;
background: linear-gradient(135deg, #ff8e59, #f05c2b);
box-shadow: 0 8px 20px rgba(228, 83, 39, 0.3);
}
/* Capture result card: the four things a screenshot raises, one click each. */
.result-card {
position: relative;
display: grid;
grid-template-columns: 46px 1fr auto;
align-items: center;
gap: 12px;
width: calc(100% - 2px);
height: calc(100% - 2px);
margin: 1px;
padding: 12px 14px 14px;
border-radius: 16px;
overflow: hidden;
background: rgba(255, 250, 245, 0.96);
border: 1px solid rgba(91, 55, 35, 0.14);
box-shadow: 0 18px 44px rgba(48, 26, 14, 0.24);
color: #2b1d16;
animation: result-card-in 0.22s cubic-bezier(0.22, 1, 0.36, 1);
}
@keyframes result-card-in {
from {
opacity: 0;
transform: translateY(14px) scale(0.97);
}
}
.result-card-thumb {
width: 46px;
height: 46px;
display: grid;
place-items: center;
border-radius: 11px;
overflow: hidden;
color: #d15f31;
background: #ffeadc;
}
.result-card-thumb.video {
color: #c94d5c;
background: #ffe5e9;
}
.result-card-thumb img {
width: 100%;
height: 100%;
object-fit: cover;
display: block;
}
.result-card-copy {
display: grid;
gap: 2px;
min-width: 0;
}
.result-card-copy strong {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-sm);
}
.result-card-copy span,
.result-card-copy em {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-style: normal;
color: rgba(91, 55, 35, 0.68);
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.result-card-actions {
display: flex;
align-items: center;
gap: 5px;
}
.result-card-actions button {
display: grid;
place-items: center;
width: 28px;
height: 28px;
border: 0;
border-radius: 9px;
background: rgba(91, 55, 35, 0.06);
color: #4a2b1b;
cursor: pointer;
transition:
background 0.15s ease,
transform 0.15s ease;
}
.result-card-actions button:hover {
background: #f04f24;
color: #fffdf9;
transform: translateY(-1px);
}
.result-card-actions .result-card-open {
width: auto;
padding: 0 11px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 600;
}
.result-card-fuse {
position: absolute;
left: 0;
bottom: 0;
height: 2px;
background: linear-gradient(90deg, #f04f24, #ffb27a);
transition: width 0.1s linear;
}
/* History library: pinned rows, and the list is a real list now. */
.home-recent-list {
list-style: none;
padding-left: 0;
margin-left: 0;
}
.home-recent.is-pinned .home-recent-icon {
box-shadow: inset 0 0 0 1.5px rgba(240, 79, 36, 0.55);
}
2026-11-19 09:48:28 +00:00
/* The favourite's own mark, on the leading corner of the thumbnail.
The star that sets a favourite lives in the row's action cluster, and that cluster
is `opacity: 0` until the pointer arrives, so across a list whose whole point is
outliving the files it names, a favourited file looked exactly like an ordinary one
until you hovered it. This mark is the half of the state that survives without a
hover; the inset ring above stays as the quiet half.
It hangs from the row rather than the thumbnail: the icon box is `overflow: hidden`
to clip pictures to its rounded corners, so a badge on that box would be cut off.
The row is already `position: relative`, and its own padding is the gutter the badge
sits in, which is why no thumbnail in the list has to move over it. On its own disc
it stays readable over a picture that happens to be dark, which a bare star would
not. */
.home-recent-favorite {
position: absolute;
top: 3px;
left: 3px;
z-index: 1;
display: grid;
place-items: center;
width: 15px;
height: 15px;
border-radius: 999px;
color: #e8891b;
background: rgba(255, 252, 249, 0.94);
box-shadow: 0 1px 3px rgba(60, 33, 18, 0.24);
/* The badge belongs to the row, not to the pointer: neither opening the file nor
dragging the row out of Shift may be interrupted by it. */
pointer-events: none;
}
.home-card-clear {
flex: none;
margin-left: -4px;
}
.home-recent-search {
display: flex;
align-items: center;
gap: 7px;
flex: none;
margin-top: 10px;
padding: 6px 9px;
border-radius: 10px;
background: rgba(91, 55, 35, 0.05);
color: rgba(91, 55, 35, 0.55);
}
.home-recent-search input {
flex: 1;
min-width: 0;
border: 0;
background: transparent;
color: #3a251b;
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
font-size: var(--text-2xs);
outline: none;
}
.home-recent-search button {
display: grid;
place-items: center;
width: 18px;
height: 18px;
border: 0;
border-radius: 6px;
background: rgba(91, 55, 35, 0.1);
color: #4a2b1b;
cursor: pointer;
}
.home-recent-search button:hover {
background: #f04f24;
color: #fffdf9;
}
/* Guided first-run checks: a modal card over the main window, using the same warm
palette and type scale as the settings drawer it reports on. */
.setup-scrim {
position: fixed;
inset: 0;
z-index: 60;
display: grid;
place-items: center;
padding: 24px;
background: rgba(48, 26, 14, 0.32);
backdrop-filter: blur(6px);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
animation: setup-fade 0.22s ease-out;
}
.setup-card {
width: min(560px, 100%);
display: grid;
gap: 14px;
padding: 20px 22px 16px;
border: 1px solid rgba(190, 83, 42, 0.16);
border-radius: 16px;
background: #fffaf6;
box-shadow: 0 26px 60px rgba(70, 32, 14, 0.24);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
animation: setup-rise 0.26s cubic-bezier(0.22, 0.8, 0.3, 1);
}
.setup-head {
display: flex;
align-items: flex-start;
justify-content: space-between;
gap: 14px;
}
.setup-head h2 {
margin: 0;
color: #3c2214;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-lg);
font-weight: 700;
letter-spacing: -0.01em;
}
.setup-head p {
margin: 5px 0 0;
max-width: 46ch;
color: rgba(91, 55, 35, 0.66);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
line-height: 1.5;
}
.setup-refresh {
flex: none;
display: inline-flex;
align-items: center;
gap: 5px;
height: 26px;
padding: 0 10px;
border: 1px solid rgba(190, 83, 42, 0.2);
border-radius: 8px;
color: #a84c29;
background: #fff1e7;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 700;
cursor: pointer;
}
.setup-list {
display: grid;
gap: 7px;
margin: 0;
padding: 0;
list-style: none;
}
.setup-row {
display: grid;
grid-template-columns: 26px 1fr auto;
align-items: center;
gap: 10px;
padding: 9px 11px;
border: 1px solid rgba(120, 70, 40, 0.12);
border-radius: 11px;
background: rgba(255, 255, 255, 0.7);
feat(ui): spend the OCR button instead of explaining it, and unify how the app speaks Two changes, one goal: the same gesture and the same news should look and read the same way wherever they happen. Dropping a file OCR cannot read used to be answered after the fact - the drop ran, refused, and popped "文字识别仅支持图片格式". The user had to do the wrong thing first and then be told. Now the decision happens when the drag starts: MainWindow records the files in flight (`dragPaths`, from the native `enter` payload or from a Recent row's `dragstart`) and marks the button spent for the whole gesture with `is-drop-unavailable`, so the refusal is visible before the pointer is committed and releasing on it is inert and silent. Both drag sources were verified in a production build, including the reverse case: an image still lights the button and opens the editor. `over` carries no paths and `dataTransfer` is unreadable during `dragover`, so the paths have to be registered at the start - a later refactor that reads them from the move event gets nothing. The audit that followed found the same class of problem in the messaging, and worse: the app said one thing three ways. Prompts were the largest gap. A Rust-authored sentence reached the screen verbatim, so a Chinese interface answered Convert with `Saved 1 file.`, and macOS's first-run write-permission failure was one long English line. Rust now names the outcome or the failure (`outcomeSaved`, `errCaptureBlocked`) and the interface words it; `translate` still returns an unknown key unchanged, so genuine technical detail - `ffmpeg exited with status 137` - is reported as it is rather than flattened into a generic line. `feedback.test.ts` scans the Rust sources and fails on any code without wording in both languages, and on any outcome the worder does not know; both directions were checked by breaking them. It also asserts the two dictionaries list identical keys, which was silently false before. Durations were arbitrary: the identical share result showed for 2.6s in the ring and 3.6s in the main window, one file's `processing` message lived 12s in one branch and 120s in another, and generic errors used 2200/2400/3000/3200/3800. `FEEDBACK` is now the only ladder, and `hold` is reserved for tasks that report progress and must not expire mid-task. Error text had three normalisation idioms, two inside the same file; `messageFrom()` is the only one left. Share failures reported twice at once - a banner saying "could not send" plus a toast naming a different reason - and now report once, in the panel, with the real reason. The editor's failure notices wore a green check and lasted 1.4s; a clipboard refusal was silent, and an OCR failure printed into the text box as though it had been read from the image. Disabled controls were dimmed at nine different opacities across the app, three buttons were disabled in JS with no CSS at all, and several `:hover` rules answered a disabled control. `--dimmed` plus `cursor: default` and `:not(:disabled)` hovers is now the single treatment, and the OCR drop-target state joins it. Every transient message is a live region, three unlabeled icon buttons are named, Escape closes the settings sheet and the first-run panel, the main toast is raised above every sheet of its window, and nine raw px font sizes went back onto the type ladder. Out of scope, deliberately: the accent is still ~87 literals rather than one variable, and the muted warm greys are still written many ways. Both need a visual pass, not a search and replace.
2026-11-01 08:18:20 +00:00
transition: border-color 0.16s ease;
}
.setup-row.is-problem {
border-color: rgba(217, 79, 31, 0.32);
background: rgba(255, 241, 232, 0.8);
}
.setup-row.is-ok {
border-color: rgba(28, 110, 74, 0.2);
}
.setup-row-icon {
display: grid;
place-items: center;
width: 26px;
height: 26px;
border-radius: 8px;
color: #a84c29;
background: rgba(240, 79, 36, 0.09);
}
.setup-row.is-ok .setup-row-icon {
color: #1c6e4a;
background: rgba(28, 110, 74, 0.1);
}
.setup-row-body {
display: grid;
gap: 2px;
min-width: 0;
}
.setup-row-body strong {
color: #3c2214;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
font-weight: 700;
}
.setup-row-body small {
display: flex;
align-items: center;
gap: 5px;
color: rgba(91, 55, 35, 0.7);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
line-height: 1.45;
}
.setup-row-body .settings-link {
justify-self: start;
padding: 0;
border: 0;
background: none;
color: #a84c29;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 700;
cursor: pointer;
text-decoration: underline;
text-underline-offset: 2px;
}
.setup-state {
display: inline-flex;
align-items: center;
gap: 4px;
color: rgba(91, 55, 35, 0.55);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-3xs);
font-weight: 700;
letter-spacing: 0.04em;
text-transform: uppercase;
white-space: nowrap;
}
.setup-state.is-ok {
color: #1c6e4a;
}
.setup-state.is-problem {
color: #c24615;
}
.setup-paths {
display: flex;
flex-wrap: wrap;
gap: 5px;
}
.setup-paths code {
padding: 3px 7px;
border-radius: 7px;
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
background: rgba(240, 79, 36, 0.07);
color: rgba(60, 34, 20, 0.8);
font-size: var(--text-3xs);
}
.setup-foot {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
padding-top: 4px;
border-top: 1px solid rgba(120, 70, 40, 0.1);
}
.setup-foot span {
color: rgba(91, 55, 35, 0.6);
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
font-size: var(--text-2xs);
line-height: 1.4;
}
.setup-foot .runtime-install {
feat(ui): drop onto a button, and read the panels again Three changes to the main window, requested together. A file drop is now aimed. The three buttons are the only drop targets and the button you release on is the action it runs; a release anywhere else on the panel runs nothing and says so, instead of opening an action ring nobody asked for. This replaces the old fallback in both delivery paths - the DOM handler and the native webview drop - because two routes to the same gesture must not have two different rules. dropFiles therefore takes a required action rather than an optional one, and the actions ring is still reachable from the Shift-drag gesture and from a file type with no convertible formats. Recent rows can be dragged back onto those buttons. A row leaves Shift as a real file drag, so one gesture can be reported twice, once by the DOM and once by the native events, and which arrives first depends on the engine; recentDrag.landed lets only the first through. The hint under the buttons names the affordance, which is otherwise invisible, and all three buttons light up as candidates for as long as any drag is in flight - a native one via dragging, an internal one via rowDragging, since a row drag inside the webview does not raise native events. Type sizes are on one ladder now (--text-3xs to --text-hero) instead of being invented per rule, which is how the settings drawer drifted down to 7-8px. 92 declarations under 12px became one. The drawer is wider, its tabs are pills, and the runtime, share, setup and radial surfaces moved onto the same scale. The capture-behaviour setting is removed: the CaptureAfter enum, its field, its command and its UI. A finished capture always shows the result card, falling back to the editor when a card window cannot be created. Stored settings that still carry captureAfter load unchanged, because the struct does not deny unknown fields. Also dropped 23 i18n keys no surface used, one dead re-export in history.ts, and a stale .home-drop p rule that was outranking the new hint and sizing it as body copy. tsconfig now turns on noUnusedLocals, noUnusedParameters and noFallthroughCasesInSwitch, which is what keeps the dead imports from coming back; the tree already passes all three.
2026-11-01 04:02:24 +00:00
flex: none;
white-space: nowrap;
margin-top: 0;
}
@keyframes setup-fade {
from {
opacity: 0;
}
}
@keyframes setup-rise {
from {
opacity: 0;
transform: translateY(10px) scale(0.985);
}
}