Commit Graph
2706 Commits
Author SHA1 Message Date
LGUG2Z 4e2c50e526 chore(repo): combine candidate 3b with the KDE handover scenario fix (candidate 3c)
Gate candidate 3c: wip-cand3b (cand3 + the bar e2e scenario) plus wip-u-kdefix (handover precondition in both copies of the shared e2e lib, KDE vm-commands bring_back step). The shared e2e/lib handover scenario is also what the Windows runner runs, so the Windows gate must include it.
2026-11-05 15:03:26 -08:00
LGUG2Z b680dbd31d test(kde): vm-commands brings the swept windows back before handover
Scenario precondition fix for the vm-commands failure "[shared] win3 is inside the work area and
not on a tile of the layout" (see the previous revision for the log evidence).

The shared sweep sends windows to other workspaces (send-to-last-workspace and the like), so
by the time handover ran, win3 was alone on workspace 0 and win1/win2/win5 were parked on
workspace 3. New KDE step bring_back, between replace_configuration and handover: while another
workspace of the first monitor has windows, focus it and send-to-workspace 0, then focus
workspace 0 and check that it has two containers or more and is the focused one. The handover
check is untouched.

Native pytest of the VM lib: 320 passed; ruff check and format clean. The step itself only runs
in the VM.
VM verification: not yet (vm-commands on baseline-with-fix and candidate, ~20 min each, after the
KDE VM run).
2026-11-05 15:03:26 -08:00
LGUG2Z 61d6423fdd test(e2e): handover needs two tiled containers on the workspace, or says so
Scenario precondition fix; the check "the unmanaged window is inside the work area and not on a
tile of the layout" itself stays as strict as it was.

The KDE VM suite vm-commands failed it on a calm host, on the original komorebi-for-kde tip
(7d19fd40) and on the refactored stage alike, with the same numbers each time: work area
(0,0,1920,1080), layout a single tile (10,10,1900,1060), win3 at (10,10,1896,1050) (within the
24 px tolerance of that tile), win1/win2/win5 parked on workspace 3. After the sweep win3 was the
only window on its workspace. Unmanaging a lone window leaves it on the tile it was put on, and
an emptied workspace has nothing to calculate, so it keeps its last layout; "not on a tile" could
never hold. The scenario now checks first that the focused workspace has at least two tiled
containers and, if not, fails with a message that says so (and the describe() dump) instead of
the misleading unmanage failure. Windows runs handover as its own suite with its three tiled
clients on workspace 0, so the precondition holds there.

The same file lives in e2e/lib and in komorebi-for-kde/nix/tests/vm/lib; both are edited alike. A
fake-platform test covers the precondition; the existing handover cases still fail where they
should.

Native pytest of the VM lib: 320 passed; ruff check and format clean.
VM verification: not yet (vm-commands on baseline-with-fix and candidate, ~20 min each, after the
KDE VM run).
2026-11-05 15:03:24 -08:00
LGUG2Z 8610f117f2 chore(repo): combine candidate 3 with the bar e2e scenario
Gate candidate 3b: wip-u-cand3 (macOS on komorebi-core, HideSpot signature change, settings S1-S3) plus the Windows e2e scenario for the bar (wip-u-bar2: e2e/ files and the nix e2e app only). Conflicts, if any, are resolved here.
2026-11-05 10:30:05 -08:00
LGUG2Z e663e346ba merge: wip-u-kfm2 + wip-u-settings2 (candidate 3)
Merge of kfm's macOS core migration (wip-u-kfm2 9cb4f2fa) and the settings
stack through S3 (wip-u-settings2 696d2929), both on wip-u-integ2. Two files
conflicted, both macOS; every hunk is resolved the same way: take kfm's
version of the file (its new shapes: komorebi_core Monitor/Workspace,
workspace_config and monitor_config as free functions) and re-apply the S3
change to it, because the settings side only touched lines kfm moved.

- komorebi-for-mac/komorebi/src/monitor.rs: conflict 1 (imports): kfm's
  header doc kept, the DEFAULT_CONTAINER_PADDING / DEFAULT_WORKSPACE_PADDING
  imports dropped (S3). Conflict 2 (std imports): kfm's side (no VecDeque).
  The four padding reads (the two default fallbacks in the monitor's
  workspace globals) call crate::settings::container_padding() /
  workspace_padding(); the now unused Ordering import is removed.
- komorebi-for-mac/komorebi/src/static_config.rs: both conflicts are the
  padding defaults in kfm's free functions (workspace_config, monitor_config):
  kfm's text kept, the two defaults read from settings. Re-applied S3 in this
  file: apply_globals applies paddings, aspect ratio, layout_defaults and
  display_index_preferences as one Handle::update of a SharedDelta; the
  readers (layout_defaults, aspect ratio, display preferences, paddings) use
  the accessors; the statics' imports and the now unused AspectRatio imports
  are removed.

komorebi-core and the shared crates read none of the removed statics
(grep: only the unrelated DEFAULT_*_PADDING consts in komorebi-config), so no
hook is needed. S3 semantics are unchanged from wip-u-settings2 (statics
removed, one update per load, reload merges, a few keys reset); the pins
are the settings crate's reload.rs and shared tests plus the KDE
tests/config.rs.

Verified: see the run in the progress log (macOS fake-CC clippy -D warnings
-p komorebi-macos --all-targets clean at this revision).
2026-11-05 10:30:05 -08:00
LGUG2Z f0a0d71b83 test(e2e): a Windows scenario bar for komorebi-bar
New extras scenario e2e/platforms/qemu_windows/extras/bar.py, registered in
run.py as `bar` (runs after the tiling windows, like the other Windows
extras). It starts komorebi-bar in the guest with a configuration that has
storage, time, applications, komorebi workspaces and layout widgets, the
Windows-only Keyboard and Systray widgets and a `mouse` block (a message and
a command), and checks: `komorebi-bar --schema` equals the checked-in
schema.bar.json byte for byte; the process starts and its window titled
komorebi-bar appears, visible and sized; it runs 15 s (scaled); `komorebic
state` answers and komorebi does not tile the bar; commands that notify the
bar work; the bar survives `komorebic stop` and the daemon starting again as
the same process (it reconnects: it does NOT exit when the daemon stops, so
the task text "exits cleanly when komorebi stops" is checked as
`komorebic stop --bar` ending daemon and bar); screenshots are kept as
artefacts, no pixel assertions. No known failures.

Plumbing: run.py uploads komorebi-bar.exe when the binaries directory has it
(other scenarios do not need it, so older build-ref directories still work),
the nix app copies it and sets KOMOREBI_E2E_BAR_SCHEMA to the checked-in
schema (the e2e directory alone does not contain it), build-ref.sh builds it.
README and docs/dev/bar-e2e.md document it.

Verified: py_compile and ruff clean; the runner and library unit tests: 157
passed; flake.nix parses. NOT run: the scenario itself (the Windows guest is
reserved for gates), so every check is untested against a real bar and may
need adjusting (window title, timings, the Systray widget inside the VM).
Needs gate: win-e2e `bar`.
2026-11-05 10:30:05 -08:00
LGUG2Z cacd508a91 docs(core): section 15, the macOS layers moved and what stayed macOS's
Records the HideSpot change and the three macOS layers (container, workspace,
monitor) as done, lists the functions that stay in the macOS extension traits,
and notes that ContainerExt is the old container code kept for the daemon's own
call sites.

Verified: documentation only.
2026-11-05 10:30:05 -08:00
LGUG2Z 0499b5c7a3 docs(settings): record S1, S2 for Windows and S3 for all three daemons
Section 9 of docs/dev/settings.md: what S3 moved, how apply_globals and the
command write it, how readers get it, and that the only BEHAVIOUR is the
single publish.

Verified: not applicable (documentation).
2026-11-05 10:30:05 -08:00
LGUG2Z db6d04fa94 refactor(mac): the daemon's Monitor is komorebi_core::Monitor<MacosPlatform>
Step 11(iii), the Monitor layer. BEHAVIOUR (type-checked and clippy-clean with the
fake CC; the macOS tests are the oracle and have not run).

pub type Monitor = komorebi_core::Monitor<MacosPlatform>. MacosPlatform
implements MonitorPlatform: the id is the u32 display id written as a number, the
serial number a String, and the extra fields MacosMonitorExtra {
window_hiding_position}, flattened into the monitor's JSON (the key was already
the last of the macOS monitor, so the text is the same; a test pins the keys and
their order). The shared monitor gives focus_workspace, add_container,
remove_workspace_by_idx, remove_workspaces, ensure_workspace_count,
new_workspace_idx and the two name/layout lookups (nine functions that were the
same text or differed only in their types). The rest stays macOS's as
MonitorExt: new, placeholder, update_focused_workspace, update_workspace_globals,
update_workspaces_globals, update_all_workspace_globals, load_focused_workspace,
hide_unfocused_workspaces, restore_focused_workspace, move_container_to_workspace
(and its '1' variant) and add_container_with_direction, because they differ from
the KDE ones in what they do (SkyLight batches, the corner, the animator). The
monitor writes its corner into each workspace's state when it updates the
globals. From<&Monitor> for MonitorConfig, an orphan impl now, is the function
monitor_config. Monitor::new and Monitor::placeholder are called through the
MonitorExt trait.

No silent bind: no MonitorExt method shares a name with a method of the shared
monitor (checked: empty intersection); the shared and the old text differ only
in types, and a call of an old signature does not compile.

Verified: fake-CC cargo clippy --locked --target aarch64-apple-darwin -p
komorebi-macos --all-targets -D warnings clean; tools/fast-check macOS PASS.
Not verified: any macOS test or run. Verified on the Mini: not yet. Gate: the
Mini's cargo test, then the hand check row in docs/dev/macos-handcheck.md.
2026-11-05 10:30:05 -08:00
LGUG2Z cab39bedfb refactor(windows): move paddings, aspect ratio, layout defaults and display preferences to settings
Plan step 10, S3. The two default paddings, the aspect ratio of a window
toggled to floating (centre with resize), layout_defaults and
display_index_preferences are no longer statics: their writers
(apply_globals through SharedDelta::apply, the DisplayIndexPreference
command) and all readers use settings() together. The semantics are the
statics': a missing padding or display_index_preferences key keeps the
value, a missing layout_defaults clears it, a missing aspect ratio is
Standard (not the initial Widescreen), and the command inserts one entry.
Readers get an owned copy from one snapshot (accessors in settings.rs).

BEHAVIOUR only in this: apply_globals used to store these keys one at a
time and now publishes the group in one update, so a thread can no longer see
a half-applied reload of them. Value semantics are pinned by
crates/komorebi-settings tests/reload.rs and shared.rs (reload merges, a
few keys reset, a load never touches groups it does not name).

Windows: window.rs, windows_api.rs, workspace.rs, monitor.rs,
monitor_reconciliator, stackbar_manager (the gap reads the container padding
from settings), state.rs, static_config.rs, process_command.rs, lib.rs.
MONITOR_INDEX_PREFERENCES stays a static (Windows only).

Verified: Windows clippy -D warnings --locked --all-targets on
komorebi-windows (cross): clean. e2e not run: config_reload, layouts,
workspaces, stackbars (container padding gap) are needed.
2026-11-05 10:30:05 -08:00
LGUG2Z c51858468e refactor(mac): the daemon's Workspace is komorebi_core::Workspace<MacosPlatform>
Step 11(iii), the Workspace layer. BEHAVIOUR (type-checked and clippy-clean with
the fake CC; the macOS tests are the oracle and have not run).

pub type Workspace = komorebi_core::Workspace<MacosPlatform>. About 53 of the
65 functions of the macOS workspace.rs are the shared ones now (identical, or
differing only in the id type, the Container type or a hook; section 14 of
core-model.md lists them). MacosPlatform implements WorkspacePlatform:
foreground_window_id and cursor_position (the same MacosApi calls),
should_act_window(_individual) (the macOS should_act with the class as a
one-element slice), the three scrolling hooks, after_floating_removed
(focus_previous_floating_window, which is shared), and the two hide spots:
hide_spot is the monitor's corner with no display (what every Window::hide
call had), hide_spot_on_display adds the display bounds from the work area
(what Workspace::hide gave the containers). The corner is MacosWorkspaceState,
which the monitor sets next to the globals (it was a field of the macOS
WorkspaceGlobals, which is now the shared type; both are serde-skipped, so
the JSON is the same). The eight functions that took the hiding position
(hide, move_window_to_container, new_floating_window,
new_container_for_focused_window, new_container_for_window,
reintegrate_monocle_container, new_monocle_container, focus_container_by_window)
are the shared ones with the spot argument; the ones that stay macOS's are
WorkspaceExt (update, apply_wallpaper, restore, remove_window,
load_static_config, prune_duplicate_windows, visible_window_details,
reap_invalid_windows_for_application, restore_windows, calculate_layouts,
set_scrolling_columns) and, in scrolling.rs, the former inherent methods now
the trait WorkspaceScrolling (an inherent impl on a type of another crate is not
allowed). The Window implements WorkspaceWindow (class is its role, path a
String). From<&Workspace> for WorkspaceConfig, an orphan impl now, is the
function workspace_config. The shared Workspace has one field macOS lacked
(initial_window_placement_rules, None and skipped when None), so the JSON
has the same keys: new test state_pin pins them.

Behaviour that is deliberately kept: floating windows are hidden at the corner
with no display (hide_spot), containers with the display; ContainerWindow's
hide and restore skip their work under cfg!(test), as the old container code did.

No silent bind: the names of the methods of WorkspaceExt, WorkspaceScrolling
and ContainerExt share no name with a method of the shared Workspace
(checked mechanically: the intersection with the core inherent names is only
Container::restore, a different type); and each of the shared functions that
used to take the corner has a different signature from the macOS one it
replaced, so a stale call is a compile error, which was the order in which the
errors showed up.

Verified: fake-CC cargo clippy --locked --target aarch64-apple-darwin -p
komorebi-macos --all-targets -D warnings clean; tools/fast-check macOS PASS.
Not verified: any macOS test or run. Verified on the Mini: not yet. Gate: the
Mini's cargo test, then the hand check added to docs/dev/macos-handcheck.md.
2026-11-05 10:30:05 -08:00
LGUG2Z faf7bbd79e refactor(macos): move paddings, aspect ratio, layout defaults and display preferences to settings
Plan step 10, S3. The two default paddings, the aspect ratio of a window
toggled to floating (centre with resize), layout_defaults and
display_index_preferences are no longer statics: their writers
(apply_globals through SharedDelta::apply, the DisplayIndexPreference
command) and all readers use settings() together. The semantics are the
statics': a missing padding or display_index_preferences key keeps the
value, a missing layout_defaults clears it, a missing aspect ratio is
Standard (not the initial Widescreen), and the command inserts one entry.
Readers get an owned copy from one snapshot (accessors in settings.rs).

BEHAVIOUR only in this: apply_globals used to store these keys one at a
time and now publishes the group in one update, so a thread can no longer see
a half-applied reload of them. Value semantics are pinned by
crates/komorebi-settings tests/reload.rs and shared.rs (reload merges, a
few keys reset, a load never touches groups it does not name).

macOS: window.rs, monitor.rs, monitor_reconciliator.rs, macos_api.rs,
state.rs, static_config.rs, process_command.rs, lib.rs. rustfmt also
reflowed a few unrelated lines in window.rs and process_command.rs.

Verified: macOS fake-CC cargo check --locked --target aarch64-apple-darwin
-p komorebi-macos --all-targets: 0 errors, 0 warnings from these files.
Nothing run on a Mac.
2026-11-05 10:30:05 -08:00
LGUG2Z e818868e02 refactor(core): the hide_spot hooks take the workspace, not its globals
The macOS corner is a property of the monitor that the workspace is on, which
the monitor gives the workspace when it updates its globals; macOS has
no field for it in the shared WorkspaceGlobals and keeps it in its
WorkspacePlatform::State, so the hooks need the workspace. hide_spot(&Workspace<P>)
and hide_spot_on_display(&Workspace<P>), called with self where they were called with
&self.globals; KDE and Windows do not override them (they return (), the
default), so nothing changes there; the test stub's two overrides follow.

Verified: native cargo test -p komorebi-core 26 passed; fast-check Windows
clippy -D warnings, KDE check + lib tests and macOS fake-CC type-check PASS. Not
verified: any run. Gates: none beyond the previous revision's (this changes no
call a daemon makes).
2026-11-05 10:30:05 -08:00
LGUG2Z 04c10a00a5 refactor(kde): move paddings, aspect ratio, layout defaults and display preferences to settings
Plan step 10, S3. The two default paddings, the aspect ratio of a window
toggled to floating (centre with resize), layout_defaults and
display_index_preferences are no longer statics: their writers
(apply_globals through SharedDelta::apply, the DisplayIndexPreference
command) and all readers use settings() together. The semantics are the
statics': a missing padding or display_index_preferences key keeps the
value, a missing layout_defaults clears it, a missing aspect ratio is
Standard (not the initial Widescreen), and the command inserts one entry.
Readers get an owned copy from one snapshot (accessors in settings.rs).

BEHAVIOUR only in this: apply_globals used to store these keys one at a
time and now publishes the group in one update, so a thread can no longer see
a half-applied reload of them. Value semantics are pinned by
crates/komorebi-settings tests/reload.rs and shared.rs (reload merges, a
few keys reset, a load never touches groups it does not name).

KDE: window.rs, desktop.rs, monitor.rs, monitor_reconciliator.rs, state.rs,
static_config.rs, process_command.rs, lib.rs and tests/config.rs (the test
harness resets the paddings through settings()).

Verified: KDE cargo test --locked -p komorebi-linux --lib --tests (lite env,
own target dir): 63 test binaries, 631 passed, 0 failed, including
tests/config.rs that loads configurations over a fake desktop. KDE VM suites
not run (gate: config reload and workspace padding suites).
2026-11-05 10:30:05 -08:00
LGUG2Z 3baf1c1b39 refactor(core): hiding takes a HideSpot and says whether it worked (D-coord-7)
BEHAVIOUR for the shared signature; none intended on KDE or Windows. Needs
the Windows and KDE gates below.

ContainerWindow gets 'type HideSpot: Copy + Default' (() on KDE and Windows;
on macOS the monitor's corner and, when known, the display bounds) and its
four operations return eyre::Result: hide_window(spot), restore_window(),
hide_stacked(spot), restore_stacked(). Container::hide(omit, spot),
restore(), load_focused_window(spot) and add_window(window, spot) return
Result (hide logs a window that cannot be hidden and goes on, as macOS does;
the others propagate). WorkspacePlatform gets two hooks with a default of
Default::default(): hide_spot(&globals) (the spot of a window) and
hide_spot_on_display(&globals) (the containers of a workspace that is being
hidden; macOS passes the display there and not for its floating windows).
The eight shared workspace functions that hide (focus_container_by_window,
new_container_for_window, move_window_to_container,
new_container_for_focused_window, new_monocle_container,
reintegrate_monocle_container, new_container_for_floating_window,
new_floating_window) and hide take the spot from the hook; new_container_for_window
and hide now return Result.

KDE and Windows: their Window impls return Ok(()) and take (); about 90 call
sites pass () and drop the Ok (let _ = ...) or use ?; nothing is hidden or
restored with a different argument than before: the same backend().hide /
restore, hide_with_border(false) and restore_with_border(false) calls run in
the same order, the Result is always Ok. macOS: the Window impl hides with
hide_on(spot.position, spot.screen) and restores, skipping both under
cfg!(test) as the old container code did; its ContainerExt is unchanged until
the Workspace layer.

No silent bind: every shared function whose behaviour depends on the spot
changed its signature (an added argument, or a Result where there was
none), so any caller written for the old form is a compile error in all
three trees (the six unused-Result warnings it produced on each of KDE and
Windows were each fixed by hand-checked 'let _ ='). The four macOS-only
extension methods (add_window_at, load_focused_window_at, hide_on,
restore_focused_window) share no name with a core inherent method (checked: the
intersection of the two name lists is empty), so no inherent method can shadow one.

Core tests: a stub window records the spot it is given; new tests pin that
a floating window is hidden at hide_spot, the containers of a hidden workspace
at hide_spot_on_display, and that stacking passes hide_spot through
add_window and load_focused_window; the container tests assert the spot.

Verified: native cargo test -p komorebi-core 26 passed; fast-check: Windows
clippy --all-targets -D warnings PASS, KDE check + lib tests PASS, macOS fake-CC
type-check PASS; KDE cargo test -p komorebi-linux --no-fail-fast 672 passed, 0
failed. Not verified: Windows and macOS tests, any run. Verified on the Mini:
not yet.
Gates for the coordinator: Windows e2e: workspaces, stacking, monocle (the
commands scenario), floating (toggle-float), lifecycle, resize, scrolling,
borders; KDE VM fast tier plus the stack, workspace, monocle and float
scenarios. These exercise exactly the hide/restore/stack paths touched.
2026-11-05 10:30:05 -08:00
LGUG2Z 6f8bc2b0ba refactor(settings): pin a configuration load through the handle
Adds crates/komorebi-settings/tests/reload.rs: a load applied through a
Handle merges what the file gives, resets layout_defaults and the aspect
ratio when absent (the first load without the key turns the initial
Widescreen into Standard, as the statics do), keeps paddings and display
index preferences, never touches groups it does not name, and a reader that
holds the earlier snapshot still sees the earlier load whole. Test only.

Verified: native cargo test -p komorebi-settings: 18 unit + 3 integration
passed.
2026-11-05 10:30:05 -08:00
LGUG2Z 22e6011333 docs(core): where the macOS move stops, and the change it needs in komorebi-core
Records the result of the Container move and why Workspace<MacosPlatform> is
not started: eight shared workspace functions call the no-argument infallible
hide forms while macOS passes the monitor's corner and display and
propagates the error; four of them have the same signature as macOS's own, so
the switch would bind the shared body silently (a behaviour change that the
type-check cannot see). Proposes the core change (an associated HideSpot type
on ContainerWindow, () on KDE and Windows, taken from the workspace
globals, and a fallible result) and lists the small mismatches that also
come first (path as String, class, should_act's class slice, the scrolling
hooks).

Verified: documentation only.
2026-11-05 10:30:05 -08:00
LGUG2Z 1cb147b2f9 feat(windows): install the settings handle
New module settings.rs: WindowsSettings (empty platform part) and
settings(), a LazyLock<Handle<WindowsSettings>> starting from
Shared::defaults_for(PlatformDefaults::WINDOWS). Nothing reads it yet, so
nothing changes at runtime. A test pins that the starting settings equal the
starting values of the statics (paddings, resize delta, mouse follows focus,
border enabled/width/offset, six colours; Windows has no border radius
static). Plan step 10, S2. Pure refactor.

Verified: Windows clippy -D warnings --locked --all-targets on
komorebi-windows (cross, compiles the pin test; it cannot run on this host).
The pin test was not run. e2e not run.
2026-11-05 10:30:05 -08:00
LGUG2Z 283e5438fc refactor(mac): the daemon's Container is komorebi_core::Container<Window>
Step 11(iii), the Container layer. BEHAVIOUR (type-checked and unit-test
oracle only; macOS cannot run here).

pub type Container = komorebi_core::Container<Window>, with ContainerWindow
implemented for the macOS Window (id is the CGWindowID, exe_name its exe;
hide_window and restore_window use the default corner and log a failure,
because the daemon does not hide through them). The container's own struct,
accessors, preselect, idx_from_exe, contains_window, idx_for_window,
remove_window_by_idx, remove_focused_window and focus_window are now the
shared ones. The four functions that carry the monitor's WindowHidingPosition
(and for hide the display bounds), return a Result and skip the work under
cfg!(test) stay macOS's own, as ContainerExt, under names the shared type
does not use: add_window_at, load_focused_window_at, hide_on and
restore_focused_window (an inherent method of the shared type would shadow an
extension method of the same name); about 35 call sites follow. The shared
Container reads a missing 'locked' as false (macOS used to require it).
komorebi-core is a dependency of the macOS daemon (and its schemars feature).

State JSON: two new tests pin the shape ({id, locked, windows: {elements,
focused}}) and the missing-locked read; the existing round-trip test is kept.
They can only run on a Mac.

Verified: fake-CC type-check (tools/fast-check) PASS on all targets; Windows
clippy, KDE check and tests unaffected PASS. Not verified: any run. Verified
on the Mini: not yet. Gate: the Mini's cargo test; then the hand check added to
docs/dev/macos-handcheck.md (stacks, workspaces, state JSON, per-monitor
hiding corner).
2026-11-05 10:30:05 -08:00
LGUG2Z 2429e3d5fa refactor(windows): take the default constants from komorebi-settings
DEFAULT_RESIZE_DELTA, DEFAULT_MOUSE_FOLLOWS_FOCUS and the initial values of
DEFAULT_WORKSPACE_PADDING and DEFAULT_CONTAINER_PADDING now come from
komorebi_settings::shared (PlatformDefaults::WINDOWS: 10, 10; 50; true); the
statics keep their names and types, so no reader changes. Adds the
komorebi-settings dependency edge to komorebi-windows (Cargo.lock edge only;
the crate is already a workspace member). Plan step 10, S1. Pure refactor.

Verified: Windows clippy -D warnings --all-targets on komorebi-windows
(dev shell, cross, target-fast-win): clean. e2e not run; tools/e2e-needed
will report the crate as an input of komorebi.exe, behaviour is unchanged.
2026-11-05 10:30:05 -08:00
LGUG2Z c2ca6847a9 refactor(mac): Window hide, hide_on, hide_scrolling, restore, minimize and unminimize take &self
None of them mutated the window; they read the element and write through
Accessibility, so &mut self only forced callers to hold a mutable binding.
The shared ContainerWindow operations take &self (a stack member is hidden
through a shared reference), so the macOS impl needs these as &self. Six
callers lose a now-unneeded mut. No behaviour change.

Verified: macOS fake-CC type-check (tools/fast-check) PASS with no new
warning. Verified on the Mini: not yet.
2026-11-05 10:30:05 -08:00
LGUG2Z b937a3d716 chore(repo): merge kfde's core line into the package migration
Merge of wip-u-core (kfde: komorebi-core with Container, Workspace<P>, Monitor<P>) and wip-u-pkg-mig3.
Conflicts and how they were resolved:
- komorebi-for-kde/Cargo.toml, komorebi-for-kde/Cargo.lock: deleted, as in the migration (one root
  workspace); kfde's only edit there, the komorebi-core workspace dependency, is applied as a path
  dependency in the crate manifest.
- komorebi-for-kde/komorebi/Cargo.toml: the migration's manifest (inlined dependencies, package name
  komorebi-linux, [lib]/[[bin]]) plus kfde's komorebi-core dependency and the komorebi-core/schemars
  feature.
- Cargo.lock: the migration's lock re-resolved with cargo metadata --offline: the only change is the
  new komorebi-core 0.1.42 entry; no version of any other package moved (compared by name/version with
  both parents; kfde's Windows lock differs only by the komorebi -> komorebi-windows rename).
- komorebi-bar/src/widgets/komorebi.rs: deleted (the Windows bar moved to komorebi-bar/src/windows/);
  kfde's one-line edit (title: value.title() instead of value.title().ok()) applied to
  komorebi-bar/src/windows/widgets/komorebi.rs.
- komorebi-for-kde/nix/root-crates.json: crates/komorebi-core added (tools/kde-closure-check now ok with
  11 root crates).
Gates run: tools/fast-check --since wip-u-pkg-mig3: native tests, Windows clippy -D warnings, KDE check+lib+schemas, macOS fake-CC check, nix evaluation (root and both nested flakes) PASS; KDE cargo test -p komorebi-linux -p komorebic -p komorebi-client -p komorebi-hotkeys -p komorebi-core: 902 passed, 0 failed; CLI docs oracle identical x3; bar schema harness byte-identical for both bars (its Window::title stub now returns Option); bar-core tests 3+6; kde-closure-check ok; by evaluation an edit of the Windows bar or daemon leaves the kfde derivations unchanged, a KDE edit leaves Windows unchanged, and an edit of crates/komorebi-core changes Windows and kfde but not macOS. Not run: nix builds, VM, e2e (the Windows daemon changed: kfde's e2e gate applies), any Mac run.
2026-11-05 10:30:05 -08:00
LGUG2Z 6c5731cda4 docs(core): section 14, the macOS functions against the shared model
Classifies every function of komorebi-for-mac/komorebi/src/{container,
workspace,monitor}.rs against komorebi-core (or the KDE extension traits):
container 5 identical, 6 text-only, 4 real (the hiding functions); workspace
11 identical, 26 text-only, 8 differing only through hooks that exist, 8
differing by the hiding position, 4 real, 3 text in the extension trait, 5
macOS-only; monitor 5 identical, 4 text-only, 8 in the extension trait, 4
macOS-only. States the one difference that decides the order: the hiding
position and the fallible hide.

Verified: counts from a function-by-function diff run on this host (stripped
text, namesake against namesake); documentation only. Not verified: that the
text-only functions behave identically on a Mac, which the macOS tests will
show once they run on the shared code.
2026-11-05 10:30:05 -08:00
LGUG2Z 4e508c347a fix(bar): the macOS bar module's leftovers from the old layout (unused imports, f32 literal)
On the Mac Mini native clippy -D warnings failed in the macOS bar module with three findings that the fake-CC
check only printed as warnings: the re-exports of ICONS_CACHE and ImageIconId in macos/widgets/mod.rs are
unused (they were pub items of the crate root before the module move, which the lint does not flag),
and Stroke::new(1.0, ...) in macos/widgets/komorebi.rs:393 falls back to f32. The two re-exports are removed
(grep: nothing in the macOS module uses them; the Windows module does and keeps them), the literal is
1.0_f32 (the type it already had). The same sweep removed the #[allow(unused_imports)] re-export of
rgba_to_color_image, also unused on macOS. Remaining pub use lines (render, selected_frame, ui, statics,
Alignment) are used. Behaviour identical.
Gates run: macOS fake-CC check of komorebi-bar and komorebi-bar-macos --all-targets: no warning left in the
bar; Windows clippy -D warnings PASS; S/bar2 schemas byte-identical. Not run: native macOS clippy (the Mini).
2026-11-05 10:30:05 -08:00
LGUG2Z 6fa0819605 refactor(core): a ContainerWindow is Clone, not Copy
Step 11(iii) prerequisite. The macOS Window holds retained Accessibility
references and cannot be Copy, so the bound of ContainerWindow is Clone.
KDE and Windows windows are still Copy; they satisfy it unchanged. The seven
places in komorebi-core/src/workspace.rs that copied a window out of a
borrowed Option (if let Some(window) = self.maximized_window) borrow it
instead (&self.maximized_window), and two places clone where the old text
used the value twice (new_maximized_window, new_maximized_window's
unmaximize hook). No behaviour change on KDE or Windows: a clone of a Copy
type is the copy.

Verified: native cargo test -p komorebi-core, fast-check: Windows clippy
--all-targets -D warnings PASS, KDE check + lib tests PASS (291 passed), macOS
fake-CC type-check PASS. Not run: Windows e2e (needed only if you want a
second look: no Windows window type changed).
2026-11-05 10:30:05 -08:00
LGUG2Z 072ba7a471 chore(repo): merge the kfm clippy fixes into the package migration line
wip-u-kfm carries the macOS clippy fixes (&Path, drain, filter, slice fill, sort_by_key, collapsible_match allows, capture_spike, bar stroke literals). The bar stroke literal revision touches komorebi-for-mac/komorebi-bar, which the migration moved to komorebi-bar/src/macos; conflicts are resolved here by applying the same edit at the new paths.
2026-11-05 10:30:05 -08:00
LGUG2Z 29bdd0b2c7 docs(macos): record that the Mini runs so far are compile and unit tests only
Adds a status section to the hand-check list: cargo test --workspace passed
on the Mini (daemon 366 passed, 1 ignored) and clippy is clean, but nothing
was run as a daemon, so every walk-through item stays open.

Verified: documentation only.
2026-11-05 10:30:05 -08:00
LGUG2Z afd0f82f91 style(mac-bar): spell the stroke widths 1.0_f32 (float_literal_f32_fallback)
Six literals in the macOS bar (applications.rs, komorebi.rs x3, komorebi_layout.rs,
time.rs) passed 1.0 to egui's Stroke::new, which rustc 1.99 reports as an f32
fallback (a future hard error). The Windows bar and komorebi-bar-core
already say 1.0_f32 for the same calls, so this makes the macOS bar text
match them; the value is the same f32. No behaviour change.

Verified: fake-CC cargo clippy --locked --target aarch64-apple-darwin
--workspace --all-targets -D warnings: clean (whole workspace). The Windows
bar and komorebi-bar-core are untouched. Verified on the Mini: not yet.
2026-11-05 10:30:05 -08:00
LGUG2Z b9125ddb65 style(mac): sample the capture spike's pixels with chunks(4) and a length filter (clippy)
examples/capture_spike.rs iterated bytes.chunks_exact(4), which clippy flags
as chunks_exact_with_const_size on 1.93 and as chunks_exact_to_as_chunks on
1.99 (the allow name differs between the two, so an allow cannot serve
both). chunks(4).filter(len == 4) visits the same full pixels in the same
order and still drops a trailing partial one; the spike is an example
binary, not the daemon. No behaviour change.

Verified: fake-CC cargo clippy --locked --target aarch64-apple-darwin
--workspace --all-targets -D warnings: clean (whole workspace). Verified on
the Mini: not yet.
2026-11-05 10:30:05 -08:00
LGUG2Z 6ad0554556 docs: record Monitor<P> and the four hook-shared workspace functions
docs/dev/core-model.md section 13: what Monitor<P> holds and what stays in
MonitorExt, why the two globals updates are not shared (KDE's plural one
has no border), the serde facts the tests pin (flattened map keys, the
schema order) and the hooks of promote_container, effective_layout_options,
new_floating_window and hide.

Verified: not applicable (documentation).
2026-10-31 13:19:31 -07:00
LGUG2Z c4586a9f73 refactor(windows): the monitor is komorebi-core's Monitor over WindowsPlatform
BEHAVIOUR (Windows runtime): the type of every monitor changes and the
order of the keys of its JSON with it; the content does not. Marked
because it was only type-checked and a unit test of the crate.

komorebi/src/monitor.rs no longer defines Monitor: `type Monitor =
komorebi_core::Monitor<WindowsPlatform>`. WindowsPlatform implements
MonitorPlatform: the id stays a MonitorId written as the same plain
number (the existing hmonitor_json functions), the serial number an
Option<String> (missing when read is None, as before), the fields only
Windows has are WindowsMonitorExtra {name, device_id, workspace_names},
flattened into the JSON, and known_workspace_name reads the names from
them. The three fields are monitor.extra.name, .device_id and
.workspace_names at the 56 places that read or write them (the compiler
found each), and the Monitor literals build an extra. The eight functions
that moved are gone; every other method of the old impl is a method of
MonitorExt, unchanged in body, which each caller imports.
static_config::monitor_config(&Monitor) replaces the From<&Monitor> impl
for MonitorConfig (orphan rule).

Two things the review of this revision found: a flattened map is read
through a buffer that keeps its keys as strings, so workspace_names has a
deserialize_with that parses them (a unit test in the crate pins this with
the same adapter); and the keys of the monitor's JSON now come in this
order: the common fields, then name, device_id and workspace_names. The
state fixtures and the pins compare parsed JSON, so they are unaffected;
a tool that read the text of komorebic state by position would see the
change.

Windows e2e scenarios needed: tiled, stack and float state scenarios with
komorebic state compared to e2e/lib/tests/fixtures/kfw-*.json (the
komorebi-client and the bar parse it), monitor and display tests (hot
plug, monitor reconciliator, work area changes), named workspaces
(workspace-name, ensure-named-workspaces, monitor-index-preference),
move to monitor, and the schema checks.

Verified: Windows clippy --workspace --locked --all-targets -D warnings:
PASS; komorebi-core tests PASS. Not run: Windows tests, e2e.
2026-10-31 13:17:51 -07:00
LGUG2Z 638ce12769 refactor(kde): the monitor is komorebi-core's Monitor over KdePlatform
komorebi-for-kde/komorebi/src/monitor.rs no longer defines Monitor:
`type Monitor = komorebi_core::Monitor<KdePlatform>`. KdePlatform
implements MonitorPlatform: the id is a u32 written as a number, the
serial number a String, no extra fields (NoExtra), the schema of the id
u32. The eight functions that moved are gone; every other method of the
old impl (the constructors new and placeholder, load_focused_workspace,
update_workspace_globals, update_workspaces_globals,
update_focused_workspace, move_container_to_workspace,
add_container_with_direction, assign_windows_to_workspaces) is a method
of the extension trait MonitorExt, unchanged in body, which each caller
imports. Monitor literals get extra: Default::default().
static_config::monitor_config(&Monitor) replaces the From<&Monitor> impl
for MonitorConfig (orphan rule). The JSON pins of Monitor and
MonitorInformation in monitor.rs pass unchanged. No behaviour change.

Verified: KDE cargo test --workspace --no-fail-fast (native, lite env):
875 passed, 0 failed. Not run: VM suites.
2026-10-31 13:17:50 -07:00
LGUG2Z 74b9992e1c feat(core): Monitor<P> with the shared half of monitor.rs
komorebi-core gets Monitor<P: MonitorPlatform> (MonitorPlatform extends
WorkspacePlatform), moved from komorebi-for-kde/komorebi/src/monitor.rs
and made generic: the id and serial_number_id are the platform's
associated types (Id with serialize_id/deserialize_id hooks so each daemon
keeps writing its id as the plain number it always did; SerialNumber), and
the fields only a platform has are P::Extra, flattened into the monitor's
JSON (NoExtra for a platform with none). The schema is named Monitor.
The workspace accessors (impl_ring_elements! is not generic) are written
out, and eight functions move with them: focused_workspace_layout,
focused_workspace_name, new_workspace_idx, ensure_workspace_count,
remove_workspaces, remove_workspace_by_idx, add_container and
focus_workspace, the last taking the name the platform last knew for a
new workspace from the known_workspace_name hook (Windows keeps its
names in the extra fields). WorkspacePlatform now needs Clone, Debug and
PartialEq of the platform marker and ContainerWindow needs Debug, because
the derives on the generic structs ask for them.

One serde fact the tests pin: a flattened map is read through a buffer
that keeps its keys as strings, so an extra field with integer keys (the
Windows workspace_names) needs a deserialize_with that parses them; the
Windows converge must carry it.

Tests with stub platforms: the JSON of a monitor with flat extra fields
and the id as a number, a monitor without extra fields, the name hook of
focus_workspace, the schema name and flat properties.

Verified: cargo test -p komorebi-core --features schemars (native): 27
passed, 0 failed; Windows clippy --workspace --locked --all-targets
-D warnings: PASS. Not run: the daemons.
2026-10-31 13:17:50 -07:00
LGUG2Z 979d9bcae2 refactor(windows): promote_container, effective_layout_options, new_floating_window and hide come from komorebi-core
BEHAVIOUR (Windows runtime, none expected; type-checked only): the four
methods are removed from WorkspaceExt and the workspace gets the crate's.
WindowsPlatform implements primary_container_idx (0 for the default
layouts, the primary column of a custom layout, failing as before when it
has none) and keeps the default unmaximize_window and
before_hide_containers, which do nothing, as these methods did nothing
here. effective_layout_options' Custom arm is the crate's fallback arm.

Windows e2e scenarios: promote (promote-focus, promote-window) on default
and custom layouts, float a stacked, monocle and maximized window
(toggle-float), hide on workspace switch (workspaces sweep), layout
options (layout_options and layout_options_rules).

Verified: Windows clippy --workspace --locked --all-targets -D warnings:
PASS. Not run: Windows tests, e2e.
2026-10-31 13:09:38 -07:00
LGUG2Z 763037c83c refactor(kde): promote_container, effective_layout_options, new_floating_window and hide come from komorebi-core
The four methods are removed from WorkspaceExt; the workspace gets them
from the crate. KdePlatform implements the two hooks KDE needs:
unmaximize_window (Window::unmaximize) and before_hide_containers (the
scrolling prelude that hide had inline, with the resize adjustments
returned for the crate to put back). Same behaviour: the bodies are the
ones that moved, in the same order. No behaviour change.

Verified: KDE cargo test --workspace --no-fail-fast (native, lite env):
875 passed, 0 failed (the workspace tests that exercise hide,
promote and new_floating_window included). Not run: VM suites.
2026-10-31 13:08:58 -07:00
LGUG2Z dcd707c688 feat(core): promote_container, effective_layout_options, new_floating_window and hide are shared
Four more functions of the workspace move into komorebi-core, written
from the KDE text with three hooks that have defaults: primary_container_idx
(the layout's primary position; 0 for the default layouts, Windows
overrides it for custom layouts), unmaximize_window (KDE asks the
compositor, a no-op on Windows, as new_floating_window does there today)
and before_hide_containers (the KDE scrolling prelude of hide, returning
the resize adjustments to put back). effective_layout_options needs no
hook: a layout that is not one of the defaults has no default options,
which is the Windows custom-layout arm and an unreachable pattern on KDE.
Tests with the stub platform cover promote, new_floating_window and hide.
The daemons still have their own copies; the next revisions make them use
these.

Verified: cargo test -p komorebi-core --features schemars (native): 23
passed, 0 failed. Not run: the daemons.
2026-10-31 13:02:17 -07:00
LGUG2Z ba6ad8eacd docs: propose the shared update skeleton with its hooks and the exact bodies
docs/dev/core-model.md section 12: the skeleton of Workspace::update that
can move into komorebi-core (begin_update with the Flow guard,
containers_pruned, place_monocle, maximize_in_layout,
adopt_widths_before_layout for the scrolling-in-motion condition,
monitor_rects, adjust_layout per container, place_container, end_update
returning Pass), a table of the body each daemon keeps in each hook, the
constraints that make it safe, and the unified diff of the two update
bodies at this tip as the exact record. Not implemented: it waits for the
Windows e2e gate.

Verified: not applicable (documentation).
2026-10-31 13:00:46 -07:00
LGUG2Z 20c87b0ad0 docs: record what the Workspace move landed and where the sharing stops
docs/dev/core-model.md section 11: Workspace<P> and its shared functions
are in komorebi-core and both daemons use it; the functions left in the
extension traits (remove_window, restore, new_maximized_window,
reintegrate_maximized_window, apply_wallpaper, update, the custom
layout arms) differ in what they do and not only in how they are
written, listed one by one with the difference; hide and
new_floating_window can be shared once their hooks exist. Where Monitor
stands.

Verified: not applicable (documentation).
2026-10-31 12:55:06 -07:00
LGUG2Z 948425f9ae refactor(windows): the workspace is komorebi-core's Workspace over WindowsPlatform
BEHAVIOUR (Windows runtime): the type of every workspace in the daemon
changes; by construction the code is the same. Marked because it was only
type-checked.

komorebi/src/workspace.rs no longer defines Workspace: `type Workspace =
komorebi_core::Workspace<WindowsPlatform>`, with WorkspaceLayer,
WorkspaceWindowLocation, CachedLayoutDefault and the threshold helpers
re-exported from the crate. WindowsPlatform implements WorkspacePlatform
(the window is Window, no extra state, default_padding reads
DEFAULT_CONTAINER_PADDING and DEFAULT_WORKSPACE_PADDING as Default did,
the foreground window, cursor, rule matching with the regex table and the
three scrolling lookups forward to what the file called inline;
after_floating_removed stays the default no-op, as Windows does not
refocus). The functions that moved are gone from the file; every other
method of the old impl (update, hide, restore, remove_window,
apply_wallpaper, load_static_config, border_kinds_on_show,
windows_on_show, the scrolling glue of scrolling.rs, ...) is a method of
the extension traits WorkspaceExt and WorkspaceScrolling, unchanged in
body, which each caller imports. static_config::workspace_config(&Workspace)
replaces the From<&Workspace> impl for WorkspaceConfig (orphan rule).
Workspace is built with state: Default::default() in state.rs.

Windows e2e scenarios needed (all of them touch the workspace): tiled,
stack and float state scenarios with komorebic state compared to
e2e/lib/tests/fixtures/kfw-{tiled,stack,float}.json; commands, workspaces,
stacking, scrolling, resize, borders and animation sweeps; workspace
rules and initial_window_placement rules; focus and move across
workspaces and monitors; the schema checks.

Verified: Windows clippy --workspace --locked --all-targets -D warnings:
PASS. Not run: Windows tests, e2e.
2026-10-31 12:53:42 -07:00
LGUG2Z c23569a337 docs: macOS commands name komorebi-macos, not komorebi
The Mac Mini run failed on -p komorebi: the daemon packages are komorebi-macos and komorebi-windows (the
single komorebi package is step 8). Corrected the command list and the note.
2026-10-31 12:53:29 -07:00
LGUG2Z 5cdb1ab33a fix(bar-core): WidgetConfig::supported as matches!
clippy::match_like_matches_macro (-D warnings, seen by native clippy on the Mac Mini) flagged the match
with a Keyboard/Media/Systray arm of cfg!(target_os = "windows") and a true arm. The same boolean is
written !matches!(self, Keyboard | Media | Systray) || cfg!(target_os = "windows"): false only for those
three variants off Windows. Behaviour identical.
Gates run: Windows clippy -D warnings PASS; native cargo clippy -p komorebi-bar-core --all-targets -D
warnings PASS; bar-core tests (3 unit + 6 oracle) PASS; macOS fake-CC check PASS.
2026-10-31 12:53:21 -07:00
LGUG2Z 0679be6621 refactor(kde): the workspace is komorebi-core's Workspace over KdePlatform
komorebi-for-kde/komorebi/src/workspace.rs no longer defines Workspace:
`type Workspace = komorebi_core::Workspace<KdePlatform>`, with
WorkspaceLayer, WorkspaceWindowLocation, CachedLayoutDefault and the
threshold helpers re-exported from the crate. KdePlatform implements
WorkspacePlatform (the window is Window, the state holds
scrolling_placed, the hooks forward to window::foreground_window_id and
cursor_position, to should_act_window with the regex table, to the three
scrolling lookups, and after_floating_removed refocuses a floating
window). The functions that moved in the previous revision are gone from
the file; every other method of the old impl (update, hide, restore,
remove_window, apply_wallpaper, load_static_config, adopt_maximized_window,
the scrolling glue of scrolling.rs, ...) is now a method of the extension
traits WorkspaceExt (workspace.rs) and WorkspaceScrolling (scrolling.rs),
unchanged in body, which each caller imports. Workspace.scrolling_placed is
state.scrolling_placed. static_config::workspace_config(&Workspace) replaces
the From<&Workspace> impl for WorkspaceConfig, which the orphan rule
forbids. The tests stay in place.

No behaviour change: same bodies, same order; serialised state and the
schema are the ones tests/schemas.rs and the fixtures pin.

Verified: KDE cargo test --workspace --no-fail-fast (native, lite env):
875 passed, 0 failed. Not run: VM suites.
2026-10-31 12:50:34 -07:00
LGUG2Z f225e51982 feat(core): Workspace<P> with the shared half of workspace.rs
komorebi-core gets Workspace<P: WorkspacePlatform>, moved from
komorebi-for-kde/komorebi/src/workspace.rs (KDE is the base), together
with WorkspaceLayer, WorkspaceWindowLocation, CachedLayoutDefault and the
two threshold helpers, and these 52 functions of its impl, whose text is
the same on both daemons (add_container_to_back/front, the container
focus and removal family, insert_container_at_idx, swap_containers,
preselect and monocle operations, new_container_for_window and
resolve_placement_index, location_from_exe, visible_windows, the
enforce_resize_* family, the window lookups, remove_floating_window and
the floating focus helpers, is_scrolling). They are generic over
P::Window (Container<P::Window>, PlatformWindowId<P>), and every private
function is pub so the daemons' own methods can call it. The accessors
the impl_ring_elements! macro made are written out.

WorkspacePlatform is the hook trait: Window (a WorkspaceWindow), State
(what only a platform keeps in a workspace; skipped in the JSON and the
schema), default_padding, foreground_window_id, cursor_position,
should_act_window and should_act_window_individual (the platform holds
the compiled regexes), the three scrolling lookups and
after_floating_removed (KDE refocuses a floating window). Default for
Workspace<P> is the KDE one with the padding from the hook. serde and
schemars bounds are on P::Window; the schema is named Workspace.

Not used by any daemon yet; the next revisions make each daemon use it.
Four tests with a stub platform cover new_container_for_window, the
focus, the JSON keys and the default.

Verified: cargo test -p komorebi-core --features schemars (native): 20
passed, 0 failed; Windows clippy --workspace --locked --all-targets
-D warnings: PASS (compiles the crate). Not run: the daemons.
2026-10-31 12:50:34 -07:00
LGUG2Z 75688cf74f docs: bar steps B0-B3 done; what to run on the Mac Mini
Marks the bar steps as executed (B4 left, why), and lists the cargo build, clippy, test and schema commands
for aarch64-darwin per revision. Not verified: any of them on a Mac.
2026-10-31 12:45:37 -07:00
LGUG2Z 7d4ea893cc refactor(bar): one komorebi-bar package with a module per platform
The macOS bar module moves from komorebi-for-mac/komorebi-bar/src/macos to komorebi-bar/src/macos (the
include_str! path follows), komorebi-bar/src/main.rs is a cfg_select! over target_os that runs
windows::main or macos::main, and komorebi-bar/Cargo.toml has what both share in [dependencies] and the
rest in per-target tables (Windows: windows, windows-core, windows-icons x2, systray-util, tokio, regex,
which, egui_extras, netdev 0.46, sysinfo 0.39, komorebi-themes without default features; macOS: objc2,
objc2-app-kit, icns, raw-window-handle, netdev 0.40, sysinfo 0.38, komorebi-themes with defaults), so each
platform keeps the versions it had. The old komorebi-bar-macos package stays as a shim that includes the
moved module. The macOS flake builds -p komorebi-bar and its source filter takes the unified package's
manifest, main.rs and src/macos; the Windows filter leaves src/macos out. The bar does not build for
Linux (no arm of the cfg_select), as before.

Gates run: Windows clippy --all-targets -D warnings PASS; macOS fake-CC check --locked --all-targets of
-p komorebi-bar and -p komorebi-bar-macos PASS (type check only); bar-core schema oracle (3 + 6) PASS; the
S/bar2 harness regenerates schema.bar.json for Windows (9091 lines) and macOS (3774) byte-identical to the
checked-in files; tools/kde-closure-check ok; CLI docs oracle identical x3; nix evaluation PASS and by
evaluation an edit of komorebi-bar/src/windows changes the Windows derivations only (the macOS side cannot
be evaluated on this Linux host). Not run: nix builds, any bar run (Windows screenshot gate and the Mac
hand check are owed).
2026-10-31 12:45:25 -07:00
LGUG2Z bdd811f2d4 refactor(bar): the macOS bar is a module of its package (move)
komorebi-for-mac/komorebi-bar/src/{bar,config,os}.rs and widgets/ move to src/macos/, main.rs to
macos/mod.rs (pub fn main); src/main.rs is a caller. Mechanical edits only: crate:: becomes
crate::macos:: (all sites), the include_str! path gets one more ../, and the unused root re-export of
komorebi_bar_core::platform is dropped.

Gates run: macOS fake-CC check of komorebi-bar-macos --locked --all-targets PASS (type check only); bar-core
schema oracle PASS; S/bar2 harness regenerates both bar schemas byte-identical to the checked-in files
(macOS 3774 lines, Windows 9091). Not run: any bar run on a Mac (the user's Mac check).
2026-10-31 12:41:55 -07:00
LGUG2Z 146cd7ff54 refactor(bar): the Windows bar is a module of the komorebi-bar package (move)
komorebi-bar/src/{bar,config,os}.rs and widgets/ move to komorebi-bar/src/windows/, main.rs to
windows/mod.rs (pub fn main); src/main.rs is a four-line caller. Mechanical edits only: crate:: becomes
crate::windows:: (all sites), the include_str! path gets one more ../, and the unused root re-export
of komorebi_bar_core::platform is dropped (the main installs the platform by its full path). This
prepares one package with a module per platform; behaviour is the same code.

Gates run: Windows clippy --all-targets -D warnings PASS; bar-core schema oracle (3 unit + 6) PASS; the
S/bar2 harness (real bar sources, regen.sh, updated to read src/windows) regenerates schema.bar.json for
Windows (9091 lines) and macOS (3774 lines) byte-identical to the checked-in files; tools/e2e-needed
says the bar is not an input of the e2e binaries. Not run: the bar itself, the screenshot gate (owed).
2026-10-31 12:41:00 -07:00
LGUG2Z a35573d8eb fix(kde): StaticConfigExt takes &Path instead of &PathBuf (clippy::ptr_arg)
The KDE twin of the macOS fix: the trait declarations of preload, postload
and reload (static_config.rs:726, :732, :735; the impls follow) took
&PathBuf, introduced by the same step 3 conversion to the extension trait.
read takes &Path since the config-crate revision; the one clone of the path
is path.to_path_buf(). No behaviour change.

Verified: native cargo clippy --locked -p komorebi --all-targets -D warnings
in komorebi-for-kde: clean (the 3 ptr_arg errors that predated the backend
work are gone); cargo test --locked -p komorebi --lib: 294 passed, 0 failed.
2026-10-31 12:39:24 -07:00
LGUG2Z b558acbe17 refactor(bar): the macOS bar uses the unified komorebi-client
komorebi-for-mac/komorebi-bar depends on komorebi-client (the one package, path ../../komorebi-client)
instead of komorebi-client-macos; same module, same API. Cargo.lock only rewires that edge.
Gates: macOS fake-CC check of komorebi-bar-macos --locked --all-targets PASS (type check only); bar-core
schema oracle (cargo test -p komorebi-bar-core: 3 unit + 6 oracle) PASS. Not run: any bar run.
2026-10-31 12:38:51 -07:00
LGUG2Z 5055e8a639 style(mac): allow clippy::collapsible_match at three nested ifs, with a reason
monitor.rs (two ifs that choose where a moved container goes, inside a match
on the layout) and static_config.rs handle_asc_file (a 40-line block under
the extension check). The lint wants the if folded into the outer match
arm as a guard; doing that restructures the arms (the else branches become
extra arms) without changing what they do, which is more edit than a lint
fix should be and cannot be run here, so each site gets an allow with a
comment instead. No behaviour change. Pre-existing on the original macOS
tip 9a58e511.

Verified: fake-CC cargo clippy --locked --target aarch64-apple-darwin -p komorebi --all-targets -D warnings: the daemon lib and its tests are clean with the six hygiene and ptr_arg revisions applied (the whole-workspace run still reports newer-clippy lints that the Mini's 1.93 does not have: the bar's f32 literal fallback and examples/capture_spike.rs chunks_exact). Verified on the Mini: not yet.
2026-10-31 12:38:08 -07:00