Repository navigation
Conversation
Run optional remote tag lookups on a lazy shared worker pool so an offline remote cannot delay local tags and reference metadata. Keep remote discovery tracked for coalescing without treating it as foreground readiness work. Cover blocked network workers and load bookkeeping with regression tests; validated with the state test suite.
Compare bounded Git metadata snapshots on the monitor thread while retaining a working-tree refresh for missed filesystem events. Validate repository lifetime, load epoch and displayed revisions before applying the selective result, falling back to a full refresh when metadata or state cannot be trusted. Reuse discovered watch inputs, deduplicate control-file reads and avoid recursively rescanning linked-checkout administration directories. Cover stale results, configuration and topology changes, scan budgets and unchanged activation with regression tests.
Show tab progress for opening, explicit reloads, history changes and user operations, while retaining a quiet tab when focus or filesystem checks refresh already-ready primary data. Add spinner classification and window activation lifecycle regressions; validated with 53 window lifecycle tests.
Honor core.fscache with the platform default instead of disabling the per-walk filesystem cache. Retain refreshed stats for small indexes even below byte thresholds so clean filters are not restarted on every refresh, while preserving the large-index allocation guard. Pass cancellation through supplemental gitlink status commands. Cover filter reuse, filesystem-cache parity, index guards and cancellation; backend suite passed with 390 tests. Paired local warm scans improved about 29% on GitComet and 73% on a 20,000-file fixture.
Add opt-in JSONL startup spans through launch, fonts, renderer selection and first usable content. Distinguish ready home and repository milestones so launch benchmarks do not stop at an empty window or wait for optional remote discovery. Provide a PowerShell capture helper with isolated-profile support and graceful closure, a repository-load probe, and documented reporter instructions. Validate startup probes, launch-harness tests, trace output and real capture runs.
Treat the native System UI font alias as known on platforms that resolve it directly. Preserve catalog lookup on Linux and FreeBSD, where the alias needs resolution, and for user-selected installed families. Cover catalog-free native startup and retain existing font-resolution tests. Local launch measurements show renderer initialization still dominates total startup.
Reconcile the merged dev ratchet with the new readiness instrumentation and background-refresh spinner coverage. Record the 266 added host lines explicitly while keeping the other nine structural limits unchanged.
Avoid the supplemental Git process only for positively empty, unchanged stage-zero gitlink directories. Recheck checkout and ancestor metadata on every scan; preserve Git fallback for staged changes, initialized or missing checkouts, sparse entries, conflicts, nested repositories and reparse points. Replace native Ignore::All submodule setup with the equivalent no-op provider, since Git owns child status. Add all-lane parity and same-handle initialization regressions. All 393 backend tests passed; two five-pair release runs reduced warm GitComet status from about 101 ms to 56 ms (44%).
RepoActivated no longer prepares selected HEAD gitlinks or filesystem markers before the asynchronous monitor check. The resulting RepoExternallyChanged message still prepares the inputs its reducer uses, avoiding duplicate store-thread I/O on every focus. Cover empty activation preparation, maintenance clock and throttling, and preserved selected-path inputs for full, index and worktree refreshes.
Integrate dev 89788be, retain its removal of obsolete source-budget ratchets, and migrate performance refresh tests to the shared backend fixture helpers.
Remove the orphaned fontdb scan span left by the deleted scanner and include GPUI font discovery in the remaining catalog span. Update the profiling guide to match the merged implementation.
Keep the blocked-writer assertion while allowing ten seconds for completion after releasing the shared session lock. Other parallel session tests can contend for that process-wide lock; include the writer label in timeout diagnostics.
# Conflicts: # crates/gitcomet-git-gix/src/repo/status.rs
Worker classification only needs the effective filter=lfs assignment. Use gix's selected-attribute lookup instead of resolving every attribute for every indexed path, preserving macro overrides and lazy nested/index attribute discovery.
Settle empty line counts and large-file rows inline after both fresh status lanes and their replays finish. Preserve the generation protocol so obsolete replies cannot publish or release newer work, while dirty snapshots continue through the backend. Cover clean loads, dirty-to-clean transitions, replay and error recovery, and stale replies across subsequent dirty refreshes.
Fix the product-identity lint regression introduced by the remote metadata pool while preserving its default thread name and the existing literal exceptions. Reproduced the failing PR #633 CI check locally; identity_literals.py now passes, all seven IdentityLiteralTests pass, and Rustfmt and diff checks pass.
Watch discovery retains lexical and resolved spellings of the same file. Share control contents within each snapshot using the resolved existing-file path, while preserving both lexical discovery entries and fresh reads next capture. Proof on Windows: a portable parent/../ alias to one 3 MiB file failed before because two reads exceeded the 4 MiB budget. It now reads/budgets exactly 3 MiB; both discovery paths remain and subsequent edits invalidate the snapshot. The original duplicate-control test and regression both pass. Final state Clippy and 35 activation tests pass with this implementation unchanged.
Known symlinks and Windows junctions in discovery inputs previously made the activation snapshot unavailable, disabling unchanged-focus narrowing. Record link spelling and resolved target stamps so target edits and retargets remain visible. Stamp ancestor targets nonrecursively; recursive links and unknown reparse layouts retain the conservative fallback. Proof: an unprivileged Windows junction regression failed before and now checks stable snapshots, target edits, equal-byte retargeting, absent children, and no traversal of unrelated data. Recursive rejection leaves an empty snapshot. Final 35 activation tests and state Clippy pass; the full state suite passed 1402 tests (7 ignored) before the final conservative recursive guard. Two privilege-dependent symlink fixtures await native Unix CI.
Read the sole primary checkout from fresh configuration and refs when trust, layout, ref storage and environment permit it. Return raw HEAD IDs without loading commit objects. Preserve Git fallback for linked/unusual layouts and propagate cancellation. The negative layout check borrows shared repository paths and releases its lock before filesystem I/O. Windows release proof: two reversed AB/BA sessions, 10 process pairs per case, 5 warmups and 15 measured calls each (100 processes, 1500 warm calls). Project listing median fell 40.4844 -> 1.0428 ms; 20000-commit repo 40.4991 -> 0.9755 ms; detached checkout 40.8603 -> 1.0001 ms, about 97.5% less time. Git commands per eligible call fell 1 -> 0. Linked controls keep one Git command; paired confidence intervals cross zero, so no linked speedup is claimed. Full porcelain rows and index hashes/mtimes matched throughout. These are API timings, not app launch. Validated exact integrated source: 16 focused tests; full backend suite 422 passed, 13 ignored; release Clippy with benchmarks and warnings denied; locked production release builds. Raw evidence: target/performance-investigation/ iteration-4/worktrees-v3-analysis.json and candidate-v3-aligned-build.json.
Retain one source/projection/plan position in the details pane. Check source, selection, view and order identities before resolving the split section or materializing drawn order. Distinguish an authoritative missing file from an unavailable owner so fallback behavior remains intact; clear on repo changes. Windows release helper proof (48 cases, nine samples each): repeated selected- end lookup at 50000 files fell 2.854713 -> 0.000033 ms combined and 7.279625 -> 0.000033 ms split. This measures exact extracted lookup/order helpers versus the production cache, not complete UI frames. Actual GPUI caller at 20000 entries confirms zero warm section/position scans, projection/plan builds or order materializations. Combined-tree allocation requests fell 422182 -> 6 bytes/call; split-tree 237774 -> 6 bytes/call. The existing six-byte preference allocation remains. Four GPUI regression tests, the caller probe, 54 helper correctness cases and UI Clippy pass. Raw evidence: target/performance-investigation/iteration-4/footer-probe/ analysis-final.json with tested source/binary hashes and scope limitations.
Integrate dev 38b4973 after the separate scanner, worktree and footer fixes. The status-position provider remains alongside the new sidebar file-history commands without further integration edits. Validation: merged UI Clippy with warnings denied; 77 selected GPUI tests (4 footer, 50 file-history, 21 file-navigation, 2 status-navigation) passed. Formatting, product identity and source-size checks pass. Backend, activation scanner and cache helper remain byte-identical to their validated versions.
Wait on the child's existing Windows process handle for whole-millisecond polls instead of sleeping after Git has exited. Retain sub-millisecond sleeps and the error fallback, and preserve cancellation, silence deadlines, process-tree cleanup, and separate pipe-worker draining. Measured on this Windows computer with identical optimized build commands: three same-binary control pairs, then two reversed-order sessions with five pairs per case, five warmups and twenty samples per process. Median process medians (baseline -> candidate): - git --version: 39.46 -> 35.21 ms - HEAD lookup: 39.61 -> 36.87 ms - worktree list with activity context: 64.91 -> 62.30 ms - parsed file list: 39.69 -> 37.23 ms - stdin hashing: 39.83 -> 36.92 ms Combined paired median savings were 2.37-4.41 ms; all five combined 95% bootstrap intervals excluded zero, and observed pooled p95 improved. Both sessions' medians improved, though the second session's worktree interval crossed zero. The control differences were under 0.4 ms. No warm drain sample exceeded 1 ms. All outputs and repository/index/ref stamps matched. This measures Git-backed commands; the clean refresh profile runs no CLI commands. CPU measurements were mixed and are not an improvement claim. Validation: 52 shared-runner tests, six Win32 helper tests, affected-package Clippy with warnings denied, workspace formatting, identity literals, source layout, and git diff --check. Raw samples, frozen binaries, source hashes, and commands are under target/performance-investigation/iteration-5.
Resolve only the parent of a nested link when asserting its discovery identity. With macOS /var -> /private/var, discovery records that physical nested-link spelling after resolving the ancestor; the original fixture incorrectly expected its lexical alias. Recreate the ancestor-link topology explicitly on all platforms, including unprivileged Windows junctions. Retain checks for original leaf inputs, outer/nested link identities, target edits, equal-byte retargeting, recursive-link rejection, and exclusion of unrelated large files. Proof: the same frozen original Windows junction test passes with ordinary TEMP/TMP and fails at the CI assertion with child-only TEMP/TMP routed through an owned junction. The corrected executable passes in that exact environment and all 35 activation-related tests pass. State Clippy with warnings denied and source formatting pass. Two privilege-dependent symlink fixtures skip locally. All three macOS native CI jobs reproduced the old assertion; fresh native CI will validate the corrected fixture. Production code is byte-identical. Evidence and source hashes are preserved in target/performance-investigation/iteration-5/activation-ci-proof.
Construct the spelling-only relative target using Path::new(".").join("second")
instead of the literal "./second". Windows stores the relative target without
normalizing its separators, leaving the old fixture unreadable when the
kernel follows it. Preserve the intended distinct spelling and equal target.
Assert the stored raw target, canonical target identity and readable chain
bytes before asking activation discovery to snapshot it. Keep the production
fallback strict for genuinely unreadable links.
Evidence: both Windows x64 and ARM64 CI jobs passed the first target change
and failed only after the old spelling-only replacement. Pinned Rust passes
the original target directly to CreateSymbolicLinkW; LLVM's Windows symlink
implementation explicitly normalizes target separators for this API.
All 35 activation-related tests and state Clippy pass locally. Native
file-symlink execution still requires CI confirmation because this computer
lacks symlink privilege; the fixture explicitly skips in that case.
Production code is unchanged. Source snapshots, separate diffs, primary
source links and reports are in
target/performance-investigation/iteration-5/activation-ci-proof.
Repeated support refreshes walked every index entry to rediscover tracked .gitattributes files, including repositories without LFS patterns. Cache only the ordered path/blob descriptors against the identical parsed-index Arc. Read contents on every call, use a weak key, and keep cold row scans lazy. On Windows 11 / Ryzen AI 9 HX 370 with MiMalloc 0.7, the real support endpoint on a 262,144-entry fixture improved from 1.4784 to 0.58065 ms per repeated call: paired median saving 0.895475 ms (60.83%), 95% paired-bootstrap interval [0.88145, 0.92275] ms. The large plain fixture saved 0.8003 ms. All per-fixture first/repeated regression gates passed. These are endpoint measurements, not application startup or foreground timings. Evidence: 64 fixed acceptance processes plus 8 separate diagnostics, no replacement observations; independent raw-data audit passed. All 438 backend unit tests and 42 LFS integration tests passed, including four freshness, fallback, cancellation and read-only guards. Formatting and scoped Clippy with warnings denied passed.
Checking a theme key built and sorted the entire merged options list, reading the custom theme directory even for bundled keys. Query the embedded cache first and use the runtime map only for custom or missing keys. Extend the registry guard to verify the short circuit and unknown-key fallback. On Windows 11 / Ryzen AI 9 HX 370 with MiMalloc 0.7, first bundled-key lookup with 8 custom themes improved from 2.49925 to 1.754 ms: paired median saving 0.75045 ms (29.93%), 95% paired-bootstrap interval [0.729, 0.7969] ms. With 128 custom themes the paired saving was 8.79855 ms. Bundled warm medians fell below timer resolution; this does not mean literal zero cost. All 72 fixed processes and per-profile first/warm gates passed independent raw-data audit. Custom/missing first calls were 0.0948/0.1053 ms slower (3.78/4.35%), below the declared regression gate; warm fallback improved. These are membership endpoint measurements, not whole-app startup timings. Validation: old code fails the new lookup-count guard (35 versus 1); all 60 candidate theme tests pass, including custom edits, collisions and missing keys. Formatting and scoped Clippy with warnings denied pass.
Integrate dev's Difftastic and panic-containment changes. Resolve the shared-foundation conflicts while preserving the runtime JSON dependency for startup tracing and exporting both panic and startup_trace.
Add PowerShell helpers for detailed samply capture, matching-symbol viewing, startup milestones, and separately instrumented allocation totals. Freeze the executable/PDB together and print a launch command using the frozen binary. Record the DX12 investigation on Ryzen AI 9 HX 370 / Radeon 890M. Five alternating release-with-debug pairs show lazy smoothing reducing median first draw from 2361.6 to 656.9 ms and repository ready from 2802.4 to 1100.6 ms. Actual-profile interaction was observed by 949.5 ms; fully loaded repository startup remains above one second. Explain sampling and memory limits, first-launch variance, and why DX11 precompilation is unrelated. Validation: all five PowerShell files parse; recorded startup, history and settings scenarios pass; four focused GPUI smoothing tests pass on DX12. Large ETL, PDB and binary artifacts stay outside version control.
Integrate the tested GPUI lazy-smoothing renderer through a focused vendor patch of gpui_ce_wgpu. The four optional corner-smoothing pipelines compile only before a frame first needs them. Preserve shader quality, reuse, resource reset, failure rollback, and DX12 retry handling. GitComet currently requests no positive corner smoothing. On Ryzen AI 9 HX 370 / Radeon 890M, five alternating release-with-debug DX12/FXC pairs reduce median launch-to-first-draw from 2361.6 to 656.9 ms and repository-ready from 2802.4 to 1100.6 ms. Sampled peak working set falls from 855.9 to 784.2 MiB. A fresh trace has about 360 ms compiler CPU versus 2264 ms originally, with no compiler samples at the four smoothed initialization callsites. Sampling rates differ; paired unprofiled runs establish the latency improvement. Vendor the exact renderer from local GPUI commit 9362a02d9832 because it is not published remotely. Keep all other GPUI packages at 0665fb07d59c and retain DX12 selection. Include upstream license, tests and upgrade notes. Only the renderer source entry changes in Cargo.lock; no version churn. Validation: exact renderer passes four smoothing tests on Radeon 890M/DX12, plus startup, history and settings live UI scenarios. Locked offline Cargo metadata resolves one local renderer and all sibling GPUI crates at the original pin. Root application integration will be rebuilt in the follow-up startup-bootstrap investigation. Full repository readiness remains above 1s.
Create AppStore and apply session settings and entry gates before opening the native window. Transfer one prepared bootstrap decision into the view so its workers can load repositories during DX12 initialization without duplicate restore requests. Consume and acknowledge retained initial feedback, preserve Git-runtime recovery and focused/workspace modes, and clear failed-open loading. Five alternating release-with-debug DX12/FXC pairs on Ryzen AI 9 HX 370 / Radeon 890M with the GitComet repository: - Median repository ready: 1183.4 -> 1015.1 ms (14.2% lower). - Ready range: 1165.8-1242.6 -> 983.2-1150.6 ms. - Median first draw: 708.2 -> 868.6 ms, a measured tradeoff. Three candidate runs overlapped loading; two deferred until window creation because the Git probe had not settled. First-frame drawing itself was not slower. The first observed launch reached ready at 1350.2 ms. Actual saved profile interaction was observed at 859.8 ms, with repository readiness at 1229.6 ms on the deferred path. These are warm-system observations, not a reboot-cold or universal subsecond guarantee. Renderer source and dependency versions match the frozen baseline, though build source identities changed. Validation: six new bootstrap regressions and 152 existing app, notification, and window-lifecycle tests passed; release-with-debug build and formatting passed; DX12 history navigation and Settings live smoke checks passed. Fresh 1 kHz samply capture retained matching symbols and ETL, with 550.5 ms of remaining ordinary-shader compiler CPU. Document the next renderer work.
Use at most three compilation lanes including the caller during Windows DX12 startup and device recovery, bounded by available parallelism. Keep all ordinary pipelines available before rendering; other backends and warm runtime rebuilds retain serial initialization. Batch shared vertex stages together. Capture device errors on their originating worker, join every worker before propagating errors/panics, preserve fatal errors, and discard partial results on failure. Thread creation failure falls back to the remaining lanes. Eight alternating pairs across two sessions on Ryzen AI 9 HX 370 / Radeon 890M, using release-with-debug, DX12/FXC, fresh app profiles and the GitComet repository: - Repository ready median: 1100.2 -> 847.8 ms; faster in every pair. - Median paired ready saving: 251.1 ms (median paired ratio 0.776). - Ready range: 1009.1-1267.5 -> 807.0-1014.7 ms; 7/8 candidates below 1 second. - First draw median: 801.6 -> 671.7 ms; two pairs regressed by 14.5/23.8 ms. Bootstrap path mix differs (baseline early 4/8, candidate early 7/8). Four matched early/early pairs still improve ready by a median 187.4 ms, at a sampled peak working-set cost of +150.3 MiB and private-byte cost of +209.8 MiB. These coarse process samples are not heap allocations or steady-state memory. The only candidate over 1 second followed the deferred Git-probe path. First observed launch: 837.6 ms first draw, 1019.6 ms harness ready. Actual saved profile: app ready 709.8 ms, interactive 755.3 ms, parent-observed interactive 879.2 ms. Empty Home: parent-observed ready 630.6 ms. These are warm-system observations, not a strict maximum or reboot-cold guarantee. Validation: release-with-debug build passed; two new DX12 GPU tests verify serial/parallel pixel equality and validation failure/retry isolation; all four smoothing regressions pass; history navigation and Settings live checks pass. Formatting/diff checks pass. Preserve exact pre-format compiled/test sources, frozen EXE/PDB hashes, paired captures and independent analysis locally; record durable results and excluded-crate test reproduction in repository docs.
Pin all six GPUI dependencies and the UI kit revision contract to 18e1b2f65899ccbc36304fbb8f9ee703ea86adc4. Resolve all 22 GPUI packages from that source and remove the superseded vendored renderer patch. Keep DX12, lazy smoothing pipelines, and bounded parallel ordinary pipeline compilation. Preserve unrelated Cargo.lock dependency selections and update integration provenance. Locked offline metadata and diff checks pass; upstream renderer validation passed 67 native tests. Fresh GitComet startup measurements follow separately.
Transfer deferred repository bootstrap exactly once between the probe worker and the attaching view. Queue runtime adoption before repository opens, keep the worker's ownership weak, reject stale results, and suppress duplicate recovery reloads when state publications coalesce. The clean Windows DX12 trace deferred bootstrap at 89.2 ms and finished Git discovery at 96.0 ms, but UI adoption waited until 434.1 ms. Five pinned-baseline launches reached first submission at median 538.0 ms and usable repository state at 831.9 ms; this change removes the handoff serialization, with end-to-end remeasurement following the renderer investigation. Add six regressions for early completion, attachment wins, stale results, dropped windows, independent windows and runtime recovery. Strengthen failed-open, entry-gate and empty-window coverage. Scope the existing synthetic-repository diagnostic assertion to its acknowledged entry. Validation: 168 targeted tests passed, rustfmt and git diff --check passed.
Advance all six GPUI dependency pins and 22 lockfile sources from 18e1b2f to 164485d7d856c0e57607501480f255d027b92709, now pushed on lazy_load_shaders. Update the UI kit revision contract without changing unrelated dependency resolution. The upstream change skips DX11 support-device initialization on successful DX12 startup while retaining explicit DX11, automatic fallback, shared device reuse, redraw ticks, and device recovery. Nine new regression tests cover the lazy initialization and recovery behavior; all 58 Windows tests, the extended headless/windowed smoke, both DX11 build configurations, strict Clippy, formatting, and diff checks passed in the GPUI worktree. The clean prior trace attributed 33.7 ms sampled CPU to eager DX11 device creation. The measured 18e1b2f baseline had median first submission 538.0 ms and repository readiness 831.9 ms over five warm-cache runs. These measurements precede both this pin and the app handoff in c55d94a; the combined release comparison follows separately. Validation: locked Windows cargo metadata resolves the exact new revision; the lockfile diff contains only GPUI source substitutions.
Record the clean GPUI 18e1b2f baseline, DXC/opaque diagnostics, and the combined c55d94a Git-probe handoff plus GPUI 164485d7 DX11-device deferral in 7ebb3e9. Preserve historical measurements while separating the retired experimental worktree confound, distinct clock origins, and sampled-memory limitations. Five alternating warm-cache DX12/FXC release-with-debug pairs on Ryzen AI 9 HX 370 / Radeon 890M measured: - Median repository readiness 897.1 -> 658.8 ms; every pair improved, with median paired saving 244.5 ms. All five candidates loaded repositories early. - Median first submission 553.9 -> 646.6 ms; four pairs regressed, with median paired regression 74.4 ms. Drawing and submission duration themselves fell; the extra delay precedes drawing. The 500 ms target remains unmet. - Sampled peak working set 412.4 -> 342.6 MiB and private bytes 656.1 -> 523.3 MiB; these short-run samples do not establish general retained-memory savings. Three separate diagnostic stage/Home pairs confirm shorter native setup but longer later renderer initialization. Home first interaction improved while Home-ready regressed; do not pool these diagnostics with the primary pairs. A successful fresh 1 kHz ETW capture has no sampled DX11 support-device creation and confirms handoff at 117.1 ms before renderer/view initialization. Status finishes before drawing. Main DX12 initialization CPU 64.2 -> 101.7 ms and total compiler CPU 368.2 -> 447.2 ms identify remaining work without proving a single cause. The first-present warm rebuild remains 17.5 ms CPU, with no second full compiler pass. Prioritize initial renderer/appearance work and investigate background overlap; gitlink status is now hidden behind renderer startup. Validation: 168 app tests and 58 native GPUI Windows tests, extended headless smoke, strict GPUI Clippy, both DX11 compile configurations, successful exact- profile release build, ten valid primary measurement runs, six valid stage runs, six graceful Home captures, DX12 History/Settings and explicit DX11 Settings live checks. The fresh ETW foreground capture and diff checks pass.
Use GPUI's default opaque background for main and Settings windows on Windows, retaining the explicit diagnostic override. The owner inspected the opaque build and approved its appearance. A prior five-pair same-binary DX12 diagnostic measured median first submission at 529.2 ms transparent versus 480.6 ms opaque; submission duration fell from 86.5 to 21.9 ms. These are historical measurements of the previous GPUI revision, not a prediction for the current combined build. The pending combined comparison will remeasure startup. Validation: rustfmt check; owner visual comparison on the frozen DX12 build with GITCOMET_WINDOW_BACKGROUND=opaque.
Pin all six workspace dependencies, 22 lockfile sources, and the revision contract to a4ee85008357c2e8e659bf8383ccae65ab62f94f on lazy_load_shaders. This includes startup resize coalescing, no surface pipeline for unsupported integrations, lazy ordinary filter pipelines, and the test-window accessor used by application frame-order regressions. The preceding DX12 trace measured 447.2 ms inclusive shader-compiler CPU across app threads and repeated surface configuration before the first frame. This pin removes unnecessary work; its elapsed startup effect will be measured on the rebuilt combined candidate. GPUI validation: 63 Windows tests; 66 WGPU unit and 5 integration tests with default features; 67 unit and 5 integration tests with external surfaces; strict default Clippy. Surface-enabled Clippy passes with only two pre-existing missing_transmute_annotations warnings allowed. Locked Windows metadata resolves successfully. GitComet UI/watcher regression validation is running against this exact pin.
Extend the existing pre-window handoff to a normal empty Home whose store still reports Git Checking. The worker adopts the already-running probe without creating repository work, and attachment retains exact ownership of late results. Missing Git, stale preferences, closed preparation, and later runtime recovery keep their existing behavior. Three prior diagnostic pairs showed Home readiness regressing from 576.5 to 625.1 ms despite earlier interaction. The store was created before discovery finished, then Home waited for a foreground runtime report and another frame. This removes that unnecessary handoff delay without changing the ready predicate. The combined release build will measure its elapsed effect. Regression coverage checks usable Open/Clone/Init controls on first attached Home, no legacy repository restore, exactly-once handoff, stale/unavailable results, and recovery after attachment. Validation against GPUI a4ee8500: all 15 bootstrap/Home tests pass, together with 67 app, 32 notification, 53 window-lifecycle, 2 runtime-probe, and 2 GPUI-version-contract checks. Tests use the ci-test profile on Windows.
Schedule automatic large-file tool discovery after the initial platform presentation attempt, using the existing next-frame callback lifecycle. GPUI's opening draw is CPU-only and callbacks run before presentation, so two callbacks are required. This is frame ordering, not a GPU completion fence. The previous DX12 capture sampled 128.6 ms of optional detector CPU around first presentation and beyond readiness. These checks do not gate startup and can wait until the first frame. Read the current runtime and tool state when the callback runs; Settings rechecks remain immediate and results still respect invalidation, window ownership, cancellation, and stale-result guards. Tests exercise actual platform frame requests/presents and native process counts, delivery without a later state snapshot, runtime changes, Settings results before release, and closed or dropped views. Existing cancellation and large-file tool lifecycle coverage remains enabled. Validation against GPUI a4ee8500: 29 large-file tool tests pass; two ignored entries are child-process fixtures. App, notification, window-lifecycle and runtime-probe regression groups also pass on Windows with the ci-test profile.
Sibling watcher inputs repeatedly stat the same ordinary directory prefixes. Cache successful proper-ancestor metadata within one expansion, then validate each reused identity before returning. Never cache terminal inputs, missing paths, errors, symlinks, or Windows reparse points. A detected identity change forces the existing setup validation and retry. Stable entries are discarded, so this adds no steady-state polling or delay to native watcher coverage. Preserve the first mismatching observation even when an earlier stamp equals the current replacement, preventing an ABA replacement from concealing the race. The preceding startup trace sampled 127.6 ms in watcher setup, including 53.8 ms under input expansion; inclusive categories overlap. Tests verify fewer metadata calls including validation, input creation and ordinary sibling churn, missing/error re-reads, replacement during expansion, and fresh-pass recovery. The combined release benchmark will measure the elapsed effect. Validation: 202 repository-monitor tests passed on Windows in the ci-test profile; one existing real-repository timing probe remains ignored. The new cache/read-count and race tests pass alongside native lifecycle, recovery, symlink, Windows path-identity, and watcher synchronization regressions.
Fall back to an NTFS directory junction in the new cached-ancestor replacement test when Windows denies symlink creation. Keep every identity, ABA, retry, resolved-path, and fresh-pass assertion, and print an explicit executed marker. The fixture command uses fixed relative names in its temporary directory. An explicit nocapture rerun revealed that Windows privilege error 1314 had previously bypassed this test body. The fallback now executes the complete race on this host as directory-junction. All six policy tests pass; production code is unchanged.
Format each startup trace and allocation payload into a complete JSON line before write_all. Preserve immediate trace visibility, successful stderr flushing, JSON escaping, timestamps, and every existing readiness predicate. Also record startup milestones on the UI journal's anchored clock before synchronous diagnostic output. A Windows experiment using the real serde_json formatter counted 59 writes per stderr payload and 44 per trace record. With PowerShell redirection, the interval between adjacent callback markers reached 29.709 ms without GPUI. Batching both records reduced the median from 3.406 to 0.079 ms. These are isolated logging measurements, not a normal application startup speedup. Regression coverage checks complete escaped JSON, a single full-write sink call per record, flushing, timestamp preservation, and file visibility before shutdown. Focused ci-test validation passed all three startup_trace tests and all eight startup_probe tests; formatting and whitespace checks passed. Production application timings remain tied to the frozen 8bd0600 binary; its rendering and readiness behavior is unchanged by this fix.
Record the opaque surface, coalesced resize, lazy filter, early Home adoption, deferred optional-tool, and validated watcher-metadata changes with their source revisions, frozen executable/PDB hashes, and test evidence. The later five-pair DX12 confirmation improves every pair: median draw 481.0 -> 440.5 ms, submission 561.2 -> 481.0 ms, and repository readiness 566.7 -> 495.8 ms. Only three candidates are ready below 500 ms; the range is 466.5-512.5 ms. Preserve the earlier 707.2 ms candidate regression separately, because its slow renderer state was not reproduced or causally explained. Include valid CPU/graphics evidence, separate watcher and Home diagnostics, the measured diagnostic-output overhead, and the bounded 3/4/6/8-worker experiment that does not justify changing the three-participant limit. Keep app callback, process-spawn, and ETW clock origins distinct, and identify status, renderer work, and observer polling as separate remaining costs.
Havunen
added a commit
that referenced
this pull request
Oct 21, 2026
Since #633 the view reports store errors that arrive before its window attaches. The popover tests' fake repository inherited the backend default, which fails submodule listing, so every view built on it started with an "Unsupported" error toast and repo_picker_row_action_says_so_when_the_repository_is_gone saw two toasts instead of one. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Havunen
added a commit
that referenced
this pull request
Oct 21, 2026
The store canonicalizes workdirs, so on Windows (8.3 RUNNER~1 temp paths) four #633 bootstrap tests waited for a workdir that never matched and timed out, or compared unequal spellings. A symlinked TMPDIR reproduces all four on Linux; with canonical paths they pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This was referenced Oct 21, 2026
Havunen
added a commit
that referenced
this pull request
Oct 21, 2026
Combines #633, #645 and #648 into one changeset on top of `dev`, without #648's Linux renderer choice. Those three PRs are closed in favour of this one. **GPUI.** Every gpui-ce crate is pinned to [`1b6f3ced`](Havunen/gpui-ce@1b6f3ce), the current head of gpui-ce `main`. It contains Havunen/gpui-ce#33, #34 and #35, the upstream sync, and the wgpu 30.0.1 upgrade (Havunen/gpui-ce#36). - DX12 pipelines are created from build-time shader bytecode, and a window whose DX12 renderer fails switches to DX11 in place. Smoothing shaders are deferred and DX12 startup runs in parallel. Vulkan shaders are precompiled to SPIR-V. - wgpu and Naga are now 30.0.1, with the font-kit revision #648 asked for. License attribution is regenerated from the new lock. - The `*_style` style-builder renames are applied. The interaction-kit source guard now matches both the old and new names; with only the old names it had stopped seeing custom styling. **Windows renderer (#645).** A runtime DX12 failure now leaves the app running on DX11, so it is recorded like a startup failure: DX11 is saved and no restart is requested. **Startup performance (#633).** - Window creation overlaps repository bootstrap, and Git discovery is adopted before Home attaches. - Large-file tool (LFS/annex) discovery is deferred until a repository opens; obsolete probes are cancelled. - Remote tag discovery is separated from local repository loads. - Activating a tab refreshes history, selected paths and linked worktrees only when their metadata changed. Clean status snapshots skip line statistics, and empty submodule checkouts skip redundant status checks. - Status scans reuse filesystem and stat caches. - Installed-font scans are skipped for native system UI aliases. - Windows uses opaque surfaces and coalesces startup resizes. - Startup stages can be traced. `docs/windows-startup-performance.md` records the measurements, and `scripts/profiling` has the capture helpers. **Linux.** #648's Auto/Vulkan/OpenGL setting is gone, along with its saved preference, restart and recovery paths, and docs. Linux uses GPUI's default renderer again; the gpui-ce side of that API was removed in Havunen/gpui-ce#36 before it merged. One part of #648 stays: when the main window fails to open, the message now includes the full error cause chain instead of advice to reboot. **Tests fixed here.** None of these failures comes from the merge itself; #633's own CI already showed the first one. - `repo_picker_row_action_says_so_when_the_repository_is_gone` failed on every native job of #633's own CI. #633 makes the view report store errors that arrive before its window attaches, and the popover tests' fake repository failed submodule listing, so every view built on it started with an "Unsupported" toast. The fake now lists no submodules. - #633's `ancestor_replaced_by_symlink_invalidates_cached_pass_and_next_pass_resolves_it` moved the replacement link into place, which refreshes its ctime. The test's equal-stamp precondition then held only within one filesystem clock tick on Linux (22 of 200 local runs failed) and never on macOS (APFS keeps nanosecond ctimes). It now swaps the parent directory instead, which leaves the link's ctime alone, and asserts on the ancestor's own stamp entry: 0 of 200 runs failed. Keeping the old stamp (`entry().or_insert`) still fails it. - Four of #633's `window_bootstrap` tests compared tempdir paths with the store's canonical workdirs, so they failed on Windows (`RUNNER~1` vs `runneradmin`). They now canonicalize their paths. A symlinked `TMPDIR` reproduced all four on Linux; with that `TMPDIR`, the full UI harness and nextest suite now pass. **Verification (local, Linux).** - Workspace suite through `scripts/ci/run.py` with the syntax corpus present: 5,425 nextest tests passed (37 skipped). libtest: UI 3,796 passed (21 ignored), UI kit 524, media 76, terminal 108. Headless contexts: core 890, diagrams 84, state 1,446, backend 1,191, app 424, all passing. - Clippy with `-D warnings`: CI's three commands; `--workspace --all-targets --all-features` on Linux; the same for `x86_64-pc-windows-gnu`. - `cargo fmt --check`, source-size, identity-literal, boundary, grammar-symbol and license `--check` scripts, CI helper tests (145) and profiling tests (106). - Not run locally: macOS, Windows, and native display tests. CI covers those.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
No description provided.