Move the client-side VCS engine to Rust

Move the complete client-side Bit VCS engine into Rust. TypeScript remains the adapter for Harmony aspects, extensions, component class hydration, installation/build tooling and CLI/UI presentation. Existing native import and workspace persistence code should become reusable parts of the engine rather than a growing collection of independent per-call accelerators.

Deliver this in substantial operation-level PRs, each containing its Rust implementation, production integration and parity qualification. Do not split the work into small protocol-only or instrumentation-only PRs.

Operation roadmap

Rust repository API and complete checkout path: version/ref resolution, validated object reads, source decoding, workspace planning, file comparison/removal/materialization and operation lifecycle. Cover clean checkout, reset/revert, local edits, conflicts, deleted files, lanes and workspace-root protection; migrate supported paths together and explicitly document remaining adapter/fallback boundaries.
Status and diff: workspace inventory, content comparison, object identity and change reporting, sharing the same repository/workspace engine.
Snapshot/tag: canonical serialization/hashing, object creation, parent/history updates, refs/index updates and local commit lifecycle.
Merge and history: graph traversal, divergence, three-way file merge, lane/component/history policy and conflict state, including continue/abort.
Fetch/push: client transfer orchestration, object selection, transport framing, cancellation and repository reconciliation, preserving existing authentication/extension adapters.
Consolidate provisioning, diagnostics and configuration: feat(rust): consolidate workspace provisioning, configuration and diagnostics #271 merged after all 14 CI checks passed; included in the perf: native cli teambit/bit#10813 integration branch.
Complete native stash save/list/load: merged in feat(rust): move stash save and restoration into the native client #272 after all 15 required CI checks passed, including detached object creation, status history publication, persisted stash state, reset/removal, successful-load cleanup and exact add/compile hydration. Local qualification: 1,299 workspace tests, 557 e2e tests, 90 stash benchmark pairs and 45 status/checkout/export regression pairs pass.
Move remaining workspace tracking and mutation operations into Rust: add, move, rename, deprecate/undeprecate, and broader patterned remove/delete/recover support, preserving provider/refactoring adapters. Native add merged in feat(rust): own workspace add tracking and publication #273; move, component rename and deprecation/undeprecation in feat(rust): native component move, rename and deprecation #274; patterned removal/deletion/recovery and scope/owner batch renaming in feat(rust): complete workspace tracking and mutation batches #275. PR feat(rust): complete workspace tracking and mutation batches #275 merged after all 18 real CI checks passed. Local qualification: 1,433 workspace tests, 696 e2e tests and 270 complete benchmark pairs (260 native, ten intentionally delegated add CI errors). All 52 eligible medians were lower on the qualified warm-metadata Linux file-remote fixtures; scope TTY was effectively tied. The complete archive retains source/binary/helper fingerprints, closed CPU monitors and earlier slower trials. The integration PR perf: native cli teambit/bit#10813 includes merge 30d0d0c.
Qualify remaining documented command modes and retire only superseded TypeScript VCS implementations after compatibility rollout. Node fallback registrations, IDE APIs, extension interfaces and server-side scope endpoints still consume the existing TypeScript services; native CLI parity alone does not make those services unused.

Native component/scope fork merged in #276 after all 19 actual CI checks passed (integration merge f8929e62c988aed6a3859b3e5682e05ab3afe2e2, included in teambit#10813). It covers local, file/HTTP remote, pattern and batch workflows, real callbacks, AST tooling and dependency-policy publication. All seven local gates pass with 1,460 workspace tests and 735 e2e tests. Windows project-path publication and the real provider timing fixture are fixed. Installation parity projects only an exact duplicate pnpm clock redraw; output, ordering and all resulting state remain strictly compared. Diagnostics for the separate intermittent doctor child/CONNECT path preserve the strict assertions and do not claim a transport fix.

Complete independent fork qualification of source 4799396e8 passes all 360 comparison pairs (350 native) across 24 workloads, with all 70 eligible native medians lower than Node. Every workload qualified on its first attempt; all samples, CPU monitors and the earlier valid slower baseline remain archived. Later Windows-only and fixture changes are recorded separately; the rebuilt Linux release binary remains byte-identical to the qualified binary. These are warm-metadata Linux file-remote measurements, without broad or cross-platform speed claims.

Native import adoption/dependent modes merged in PR #277 after all 19 actual CI checks passed (integration merge 21f08560b5f638d8cf7fdb78e9f8ddc6fa4c4031, included in teambit#10813): track-only adoption, relocation to an empty directory, silent dependent/via graph selection and root dependency writes. All seven local gates plus Rust scope pass with 1,490 workspace tests and 777 e2e tests; 25 strict import cases cover default installation, callback order and failure prefixes. Nineteen focused history-validator tests and four 1 MiB stack cases also pass. Windows stack pressure and equivalent proof/receipt path separators are fixed; recovery and batch-fork history validation uses independent released-CLI write transcripts while preserving every actual surviving byte, mode and metadata row. Complete Windows-proof runtime qualification passes 450 correct pairs (440 native), with all 88 eligible native medians lower than Node on warm-metadata Linux file-remote fixtures. Twenty valid workload results keep their original source/controller/helper identities; ten missing workloads qualified on their first attempts using a clean rebuilt, byte-identical executable and new batch-fork oracles. Earlier failed/partial/interrupted and CPU-invalid attempts remain archived under their original identities. Final report checks and all 19 actual CI checks pass. Lane adoption and history restoration merged in PR #278 (merge fb9a03413a2d07bc9f171dd79a6017427fbbbe96) after all 19 actual platform CI checks passed. The user merged before full local benchmark qualification completed. This includes lane-history checkout/revert, deleted-component restoration, real revert JSON, remote history refresh and retained provider/installer/compiler sessions. The latest correction places native linking before manifest calculation, conditionally invalidates actual component caches when package manifests change, executes real root env/application load phases and preserves manifest-phase ComponentMap identity/order separately from later linking maps. Windows directory validation preserves strict IDs/order/count while accepting equivalent platform path spellings. Independent Node bitmap-write transcripts retain exact raw backup bytes, modes, metadata and command clock windows. All seven local gates plus Rust scope pass: 1,538 workspace tests and 818 e2e cases; 23 Python history-validator tests and six Linux 1 MiB stack cases also pass.

Local qualification of c3090943e stopped after 44/49 complete workloads (660 correct pairs, 130 eligible native medians all lower than Node); this is partial evidence, not complete runtime qualification. The next restore-json workload passed ordinary and CI modes, then its colored PTY run exposed two issues: the harness parsed merged trace/JSON output directly, and Rust omitted the ANSI colors that released Node includes in JSON file statuses. The failed attempt and all original valid/CPU-invalid attempts remain preserved. Evidence publication stopped safely; no final qualification archive or compact report commit was published for this runtime. Follow-up PR #279 merged as 3eab8f4de453fad5d7816e8e6cbe889b1abafa5e after all 19 actual final-head platform CI checks passed. It preserves colored revert JSON and the real published CI error stack through read-only pre-effect delegation, keeping cached and supported file-remote successes native. All eight local checks pass (1,546 workspace tests and 822 e2e cases), together with 40 Python tests and six reduced-stack cases. Complete focused restoration qualification passes eight workloads/120 exact pairs (110 native), with all 22 eligible native medians lower than Node on warm-metadata Linux file-remote fixtures. Ten intentional CI-error delegations are excluded from native speed claims. The first-valid missing-history timings retain their original helper identity; the metadata-absence harness failure and both CPU-invalid main-history attempts remain preserved. The 49 MB evidence archive was independently downloaded, extracted and verified against every file checksum/mode and reconstructed native source; archive SHA-256 439352491ff20c1bc4e20937a7683811f4e3481a6927336d4b5ad80f86431275. Bulky reports remain outside Git. Earlier partial runtimes never qualify this executable. The shared lane installation fixture uses the existing real subscriber progress throttle and validates exact pre/post receipts in default, mutable-subscriber and phase-error cases, retaining strict output/state checks. A clean release rebuild of a7078fa189bd16ce5023809145eb8fa1eb499350 is byte-identical to the qualified executable. Its validation supplement was independently downloaded/extracted/verified; SHA-256 dc237714de9236f196e4beb7fab83b52e0d0aa89f0925079246effff7502c5e3. Full 49-workload qualification remains incomplete. All 19 actual producer CI checks passed, including Windows and the full Linux e2e/stack job. Previous head 905808e6c passed 18 checks, including every Windows adoption/provider case; its sole corruption-fixture failure exposed two legitimate Node stream error forms. The test-only correction independently qualifies both complete errors and their readable-end/error event sequences with the actual published parser/fetcher, preserves strict state/output comparisons elsewhere and rejects altered scope/cause/advice/extra output. A clean original-path release rebuild is byte-identical to 905808e6c; that runtime had no timing samples because its CI gate stopped before measurement. Earlier executable cohorts retain their original evidence and do not qualify the changed binary: the original lane-adoption runtime completed 41 workloads/615 correctness pairs; subsequent runtime partials stopped at 19, 15 and 17 valid workloads respectively. The latest partial stopped at a verified clean boundary after Windows CI exposed the remaining phase/directory gaps. Valid measurements are never rerun on an unchanged runtime; only CPU-invalid exit-zero attempts may be retried. Full reports are preserved in verified release evidence archives; Git retains small summaries/checksum indexes, and unmerged bulky report commits have been trimmed. Unsupported mutable subscriber replacements and configured-provider active-lane imports remain explicit boundaries. Graph-aware lane reset/undo-merge merged in PR #280 as 669ee4ef6f0f273e8aca1e6edc89f1844e65b2cb after all 19 actual final-head platform checks passed. It covers merged/diverged heads, sparse ancestry, inherited/exported boundaries, introduced members, snapped deletions and hidden update-dependants, with exact model/object-prefix behavior and pre-effect CI diagnostic delegation. All eight local gates pass (1,566 workspace tests and 842 e2e cases), plus 20 benchmark negative controls and nine 1 MiB stack regressions. Complete focused qualification of c4f1750d8102cc4e4b7f4c8f76c160ee182a9e37 passes eight workloads / 120 exact pairs (110 native); all 22 eligible medians are lower than Node on warm-metadata Linux file-remote fixtures, with every workload qualifying on its first attempt. Ten intentional CI-error delegations are excluded from native speed claims. The earlier executable’s valid merged-all measurement and failed TTY diagnostic remain preserved under their original identities. The 81.6 MB evidence archive was uploaded, independently downloaded/extracted and verified against all file checksums/modes and reconstructed source/binaries for both cohorts; SHA-256 98a98ce13e112e3becf7d7296257aacf5fc0574e66bf1b869de88dbabf9181f5. Full 49-workload qualification remains incomplete; native CLI parity does not make the TypeScript services unused.

Completion requirements

Rust owns operation state and the data path; file bodies should not cross into Node merely to be sent back to Rust.
Preserve the existing object format and IDs, public results/errors, bitmap behavior, hooks, remote ordering and filesystem semantics.
Reuse the native implementations completed under Rust object-import performance: large-object processing and persistence #33 and PRs Materialize workspace source files in Rust #71/Persist workspace deletion, writes and links through scoped Rust helpers #72. This issue supersedes the targeted-kernel approach for future client VCS work and complements Plan: accelerate Bit with targeted Rust rewrites #3.
Exercise source and physically compiled production adapters, real repositories/workspaces, missing/corrupt objects, cancellation, acknowledged-prefix failures and Linux/macOS/Windows behavior.
Record complete-command correctness and performance measurements with reproducible source/helper fingerprints. A migration is not evidence of a speedup: keep rollout controlled until supported behavior and measurements justify adoption.
Keep the user's checkout and installed dependency graph intact by developing and compiling in isolated worktrees/CLIs.

Initial chunk

Start with checkout and a reusable Rust repository/workspace API, based on merged #72. The filesystem-only benchmark showed no consistent gain; the next boundary must eliminate Node-mediated object-to-file round trips and own meaningful operation planning.

The workflow-only #280 timeout follow-up retains the original c4f1750 source/timings: all seven release packages were cleaned/rebuilt and the executable is byte-identical. The full Linux 842-case suite had passed before its one-hour job timeout canceled reduced-stack checks; the job limit is now90minutes. Its verified CI validation supplement has SHA-256 5025921d60de8f1dd1318d7668171ec3bd92c63b7ea4bc9d06e9f2383d60d864.

PR #281 merged as dbc914dd089166271eec7bd8be9cdb0fbae5f899 after all 19 actual final-head platform checks passed. Operation-scoped ordered rename patterns and borrowed source buffers preserve fresh callback reads. Fresh qualification of one exact executable completed 57 workloads: 855 correct alternating pairs, 825 native pairs and all 165 eligible native medians below released Node. Thirty deliberately delegated CI error pairs are excluded. This is warm-metadata Linux file-remote evidence, not a claim for every platform or workload, and does not complete the remaining compatibility rollout or authorize deleting shared TypeScript consumers. Historical valid slower c4 results remain preserved separately. The workflow-only final head rebuilds to identical release bytes. Verified full qualification evidence SHA-256 447c4ca0812d5b77e174cc24c82b16efba202105489cd5d193698685ed00d940.

PR #282 merged as 15ef7ef4e322ff8bbaedb67693c7dc60e6d77c7e, completing the final supported-mode compatibility milestone. The rust-workspace-materialization base contains identical native sources to qualified producer 78875a675140c2f24c82719722ad82765b42f420; upstream integration PR teambit#10813 includes that merge and remains open. This completes the client VCS roadmap above.

All eight local gates pass: 1,620 workspace tests and 909 end-to-end cases, plus 77 benchmark controls and nine regressions with a 1 MiB stack. All 19 actual exact-head platform/Rust CI checks passed, including the corrected Windows hub socket fixture. Complete fresh qualification of one clean-built executable passed 80 workloads / 1,200 exact alternating pairs (1,170 native). All 231 eligible native medians were lower than Node, and every workload qualified on its first attempt. Six intentionally delegated CI modes and three blocked-delete correctness-only modes make no native speed claim. Measurements use Node 22.22.0 / Bit 2.2.94 with ordinary, CI and colored TTY output on warm-metadata Linux file-remote fixtures; they do not establish broad or cross-platform speedups.

The 5.8 KB summary/checksum index and full evidence archive were independently downloaded and verified. The archive retains source/binary/helper identities, raw comparisons, closed CPU monitors and all five earlier slower or correctness-failed cohorts under their original identities. Archive SHA-256: 9b132e67ccbbaba40e4a802dfc798edf1eed184beae66c2afbf22532ca11522a. Bulky benchmark JSON remains outside Git.

The remaining TypeScript services were audited and still serve Node fallbacks, IDE/extension/workspace APIs and scope-server routes; native CLI parity did not justify deleting those consumers. Rust owns the supported client operation state and data path while actual published Harmony providers, component hydration, custom resolvers and installation/build callbacks remain adapters. Documented unsupported inputs still delegate before effects; started callbacks or writes are never replayed. The original user checkout and installed dependency graph remain intact.

Started the first substantial checkout chunk on rust-client-vcs-engine, based on merged #72, in an isolated worktree.

Implemented so far:

Rust repository Source reads with bounded decompression, complete stream/header/content-identity checks, read-only preflight and direct object-to-workspace writes.
Canonical binary detection and platform newline conversion, preserving in-place filesystem semantics and acknowledged-prefix fallback.
Production checkout integration using source-backed Vinyls, with guards for custom loaders, transforms, cache mutation and content/ref changes. Component metadata and final destination mapping remain compatible with the existing writer.
Actual checkout/reset/revert qualification using distinct versions and changed/added/removed/case-renamed/binary files, including missing and crashed helpers. Diagnostics confirm native object-backed writes, rather than merely comparing the final bytes.

This is working-branch progress, not completion of the checkout milestone. Version/ref resolution, workspace comparison/removal planning, and modified/conflict orchestration still need to move into the Rust repository/workspace API. I am keeping this work together for the larger operation-level PR requested here. No small standalone PR is being opened for these foundations, and no performance/default-rollout claim is being made.

Working checkpoint: 60552fcb8

Validation passed: 68 source/adapter/regression tests, 50 physically compiled checkout/persistence tests, 86 Rust workspace tests, canonical TypeScript lint and the inherited Rust checks. Final actual-command qualification passes Node/native/missing/crashed-helper modes; the separate native diagnostic acknowledges all four preflighted Sources and all four direct object-backed writes with zero failures. These are correctness observations, not a performance comparison.

The first substantial client VCS migration is ready for review in PR #74, based on merged #72.

Rust now resolves target versions, validates Component/Version manifests and all Source objects, computes file statuses and protected removal plans, and materializes Sources directly from a bounded cache shared throughout checkout/reset/revert. Whole-component preflight precedes removals, and invalid plans/helper failures retain canonical fallback.

Qualification passes 83 source tests, 64 physically compiled tests, 103 Rust tests, canonical lint/Bit compilation, and 30 packaged installation/discovery tests. Actual checkout/reset/revert matches Node with native, missing and crashed helpers. Nine alternating retained pairs per workload cover 4 and 260 files on tmpfs and Btrfs; all bytes/bitmap/fingerprint checks pass. Installed packaged discovery also completes a real 260-file checkout. Full results and adapter boundaries are in the PR.

Rollout remains BIT_RUST_CLIENT_VCS=on: larger checkout workloads improve locally, but small workloads and reset show no consistent gain across both filesystems.

The checkout milestone stays open. Current-workspace loading, modified-state detection, conflict/merge orchestration, bitmap policy and hooks remain in TypeScript. The next substantial chunk can move workspace inventory and comparison into the shared Rust engine for status/diff and checkout's modified-state checks; native merge/history follows the roadmap. Concurrent object-store deletion during deferred Node hydration is also documented as a remaining boundary.

Merged #74 is now the base for the next substantial client VCS chunk: #75, workspace inventory and status/diff data paths in Rust.

The shared engine now scans component candidates, reads and identifies workspace files, compares canonical Version identities, and runs bounded parallel Git diffs directly from verified repository Sources and disk snapshots. Status/mini-status/diff scopes reuse the operation helper; checkout also reuses it for current-file reads and comparison through planning/removals/materialization. Both inventory readers now use stable ComponentMap ordering.

Qualification passes 20 source and 20 compiled new tests, existing checkout/persistence/model regressions, 118 Rust workspace tests, canonical lint and 15-component compilation. Real status/diff and checkout/reset/revert outputs match with Node/native/missing/crashed helpers, with native trace coverage and exactly one helper per operation. Official release packaging and all 30 artifact/provisioning/discovery tests pass. CI includes source and compiled adapters on Linux/macOS/Windows.

Five alternating Node/native pairs per workload on tmpfs and Btrfs show similar small-workspace performance. At 260 files, native commands currently run 4.5–9.3% slower and native diff uses about 19–21% more sampled process-tree RSS. Rollout remains opt-in through BIT_RUST_CLIENT_VCS=on; the PR records these results without claiming a speedup.

The full roadmap checkboxes remain open: TypeScript still owns component metadata projection, ignore policy, bitmap and extension/presentation behavior, and deferred Source hydration retains the documented concurrent object-store deletion boundary. Following #75, the next substantial chunk should move snapshot/tag serialization, hashing, object creation and refs/history/index updates into the repository engine, then consolidate shared operation state as the remaining migrations progress.

Continued from merged #75 in #76, a substantial snapshot/tag operation chunk.

Rust now plans ordinary mainline parents/head/tag updates, verifies and reads unchanged workspace Sources directly, prepares/compresses final objects, and persists objects plus index updates in one awaited helper lifetime. Version refs retain their preallocated hashes. Guarded Source provenance survives read-only hydration and rejects subsequent mutations. Unsupported/customized paths and missing/crashed helpers retain canonical replay, with acknowledged-prefix failures retiring the child before suffix replay.

Real tag 1.0.0 → edited snap → tag 1.0.1 workflows match Node/native/missing/crashed modes exactly for stored objects, Source bytes, hashes, parents, tag aliases, index, bitmap, status and history. Diagnostics confirm actual Rust commits and direct workspace Source reads with one helper. Final local qualification passes: 129 Rust tests, 12 source/12 compiled snapshot tests, 23 source/23 compiled provenance/comparison tests, existing regressions, canonical lint/Bit compilation and 30 release artifact/provisioning/discovery tests. Final checkout/status/diff command regressions also match all four modes.

Five alternating measurement pairs on tmpfs and Btrfs cover 3- and 259-file workflows. Small commands are broadly similar; 259-file native commands are 5.7–8.4% slower with roughly 3–15% higher peak process-tree RSS. The documented results identify the benchmark revision before the final custom-Ref/fallback guards; the final candidate has separate four-mode correctness and 259-file measurement-path qualification. No speedup claim is made. #76 is ready for review; cross-platform CI is running on its final commit.

The snapshot/tag checkbox remains open: lane/merge parent policy, VersionHistory construction and remaining orchestration still need migration. Rollout remains opt-in with BIT_RUST_CLIENT_VCS=on. The next substantial chunk should move merge/history graph and lane policy into the shared engine.

The next substantial Rust client VCS chunk is implemented and qualified in #77: native repository ancestry traversal, divergence/nearest-common-snap calculation, and whole three-way file merge planning. Merge, abort, resolve and lane merge share one awaited helper lifetime. Rust reads verified workspace/repository descriptors directly, with no Source bodies in merge input frames.

Eighteen new tests pass in source and compiled modes; canonical lint/20-component Bit compilation, 141 Rust tests, 1,500 seeded graph comparisons and official release/provisioning tests pass. Real manual merge → abort → remerge → resolve and lane merge match complete files, objects, bitmap/index and history across Node/native/missing-helper/crashed-helper modes. Custom readers, live/pending mutations, missing/corrupt history and concurrent population retain canonical semantics.

Three retained alternating command pairs after warmup cover 8/264-file tmpfs and Btrfs workspaces. Large merge/remerge is 36–39% faster with lower CPU/RSS; small merges are similar, while large abort/resolve is 3–10% slower. Rollout remains opt-in with BIT_RUST_CLIENT_VCS=on. Supported boundaries and complete measurements are documented.

The full roadmap remains open: lane/squash/unrelated policy, configuration/hooks and conflict bookkeeping are still TypeScript adapters; transfer orchestration and final consolidation/removal remain to migrate. The merge/history milestone is not marked complete merely because its graph/file data path is now native.

PR #77 is merged with all 20 CI checks green. The next substantial chunk is PR #78: Rust lane snapshot parent/head policy, ordinary/squash/unrelated pending merge reconciliation, and token/revision-bound pending state transitions and persistence in the shared workspace helper.

Local qualification passes 22 source and 22 compiled adapter tests, 54 source and 54 compiled regressions, 69 unchanged canonical model tests, 154 Rust tests and strict checks, canonical private CLI lint, and 30 official packaged-helper checks. Real six-policy workspace scenarios exercise manual recovery, ours/theirs, diverged squash, unrelated histories and completed lane abort with native and failed/missing helper fallbacks. Exact source/compiled/helper fingerprints are retained in the qualification reports; complete-command measurements and cross-platform CI are in progress.

The next merge chunk is fast-forward/detached squash history rewriting and existing VersionHistory reconciliation. Configuration merge policy and broader lane orchestration remain, along with the other unchecked roadmap boundaries. The engine stays opt-in; this progress does not mark the full merge milestone complete.

I will merge each subsequent PR only after every CI check is green, then continue from its merged base.

PR #78 is merged at d1bda28a878a004ae805c79744e10b8195f3015f after all 20 CI checks passed on final head a26abc44a93d814310c20ebeaa47a607922b4519. Linux/macOS/Windows source and compiled adapters, native platforms, and all end-to-end shards are green.

Its four command benchmark cases (tmpfs/Btrfs, 8/264 files, three retained alternating pairs after warmup) all preserve exact six-policy workspace state. Measurements establish Rust operation ownership and parity, with overhead on some large paths; the engine remains opt-in. Absolute wall/CPU/process-tree RSS and reproducible fingerprints are recorded in docs/rust-object-import/client-vcs-engine.md.

The next substantial chunk is underway from this merged base: fast-forward/detached squash policy, direct verified Version commit-message reads, first-existing VersionHistory reconciliation, and lane-abort operation ownership/native clear-all. Configuration/aspect-data merging and workspace dependency reconciliation follow. The roadmap remains unchecked until each complete operation boundary and compatibility requirements are fulfilled.

PR #79 continues the merge engine migration with squash ancestry policy, fresh verified commit-message reads, first-record history reconciliation, and an owned session across completed lane aborts. Four-mode real CLI parity passed for main/lane/detached squash (one/three incoming snapshots) and abort, with successful native acknowledgements. CI and complete-command measurements are running; merge will wait for all checks to pass at the final head.

Qualification correction: the earlier #78 lane-abort harness omitted --silent, so closed stdin ended at the confirmation prompt. Those abort timings did not measure restoration and are withdrawn from the documentation. The corrected harness requires restoration output, pre-merge files/bitmap/history, backup deletion, and native pending-state/checkout acknowledgements. Other #78 operation measurements are unaffected.

The next substantial chunk is component configuration/aspect-data merge plus workspace dependency reconciliation. Remaining backup/restore orchestration and other client VCS boundaries stay tracked here.

Merged #79 at 3cb390750a7c232a2564136620daab95dbeadaea after all 20 CI checks passed at final head 3e2e55a6c889e2cd2faeb908796294a1222b2371 (intentional reconciliation skip excluded). Four-mode squash/completed-abort parity and all four complete-command performance cases passed. Wall ratios 0.96–1.09 give no broad speedup; rollout remains opt-in.

The next substantial chunk is already in progress in an isolated branch based on that merge: component configuration/aspect data, both workspace dependency reconciliation paths, and native JSONC conflict preparation/materialization around the existing backup hook. Real CLI acceptance checks currently expose silent fallback in component and import planning; those must be resolved before qualification is claimed. Backup/restore orchestration and the other remaining client VCS boundaries remain open.

Configuration and dependency merging is ready in #80, following merged #79. Rust now owns component/aspect/environment merge policy, aspect-data comparison, scope dependency rescue/deletion, workspace dependency reconciliation, and JSONC conflict planning/commit around the public backup hook.

Qualification: 192 Rust tests; 24 source/24 compiled adapter tests; 4,000 seeded actual canonical-method comparisons; four-mode real lane/import commands with exact persisted/public state and successful ACKs required for all six operations; full prior regressions, lint, model and official artifact/discovery checks. Complete-command paired measurements show larger lane workloads 28–32% lower wall time with higher RSS; small workloads/imports stay near parity. These enable earlier native stages too, so they do not isolate configuration-stage gains. Details and fingerprints are in docs/rust-object-import/client-vcs-engine.md.

Per the standing authorization, I will merge #80 only after all visible CI checks pass at its exact final head, then continue substantial chunks. Next is native lane snapshot/backup/restore and reset reference policy, preserving prompt/hook order, filesystem semantics and phase-specific recovery. The umbrella remains open: fetch/push orchestration and final engine consolidation still require work.

Merged #80 at 37a52feca79c441903ad0d44157ee74632f9754f after all 20 CI jobs succeeded at final head 19b1dc8fc2256d813ef232954ba3da7b45bc4dc5 (the merge-queue reconcile job was intentionally skipped). This moves component/environment/dependency merge policy, workspace policy updates and JSONC conflict planning into the shared Rust operation, while preserving public callbacks and unsupported-file fallbacks. The Windows recovery-candidate failure was fixed and its canonical-model CI qualification passed.

The next substantial chunk is already implemented: lane backup capture/persistence/restore, bitmap abort directory planning, and main/visible/hidden-lane reset reference policy under whole reset operation ownership. Full lint passes; 206 compiled regression tests pass. Actual Node/native/missing/crashed command state comparisons pass, and final qualification now explicitly requires native head-only and full-reset decisions plus nonzero successful recovery filesystem steps. Abort also protects workspace-root component directories in both implementations.

I am finishing revision-bound packaged-helper qualification and complete-command measurements before opening the next PR. The umbrella remains open: client transfer ownership and final engine consolidation are still outstanding. I will continue merging each migration PR only after all CI checks pass, as requested.

Opened #81: lane backup/recovery and complete reset operation ownership, including the workspace-root abort protection. Final proof requires native head-only and full reset ACKs and successful actual recovery steps in both staged-present/absent scenarios; all four modes match exact repository/workspace state. The official packaged helper passes 30 artifact/discovery tests, full lint and Rust/adapter tests pass, and the new source/compiled recovery suite runs on all three CI operating systems.

Complete-command measurements retain 32 separately staged rows across tmpfs/Btrfs and 8/264 files, with warmups and three alternating pairs. Wall ratios range 0.94–1.08 and memory generally increases; no broad speedup or default-enable change is claimed. Reproducible fingerprints, boundaries and full medians are in the PR documentation.

I will merge #81 when all CI is green. Work has started on the next substantial transfer chunk: Rust-owned object selection/collection, compressed-content spooling, export tar framing and client transaction state, with existing public authentication, remote hooks and fetch-stream cancellation preserved.

PR #81 is merged: #81

Final head b3553e8f0e76ff90c3ed22d4139cf444137b9398 passed all 20 CI checks (Linux/macOS/Windows model tests, Rust matrices, scanner lifecycle, packaging, lint and all four e2e shards); the merge-queue reconciliation job was intentionally skipped. Merge commit: 8e876d140c709a1260d6e04bafa3bb7c91dda1d3.

This chunk moves lane backup/recovery, abort filesystem phases and reset reference/history selection into the shared Rust operation. Final CI includes physical workspace-root alias protection, including macOS /var versus /private/var, and symlink regression coverage. Linux source and physically compiled regressions plus canonical lint pass for that fix. Earlier four-mode real-command and 32-row timing evidence remains bound to its recorded production/helper revisions, not relabeled to the final CI fix. Measurements show no broad speedup; rollout remains opt-in.

Next substantial chunk is client fetch/push: native compressed-object selection and framing, pending writes, transfer lifetime/cancellation, and export validation/persistence orchestration with acknowledged remote receipts. Full local snapshot/tag creation and commit ownership follows; the umbrella is still open.

PR #82 is open for the next substantial client migration: native fetch/export transfer selection, frozen compressed Sources/artifacts, canonical tar archives, filesystem pending writes, and acknowledged remote push/validate/persist/retry/cleanup/resume operations. The branch follows merged #81 on rust-workspace-materialization.

All eight real file/HTTP Node/native/missing-helper/crashed-helper states match, with the documented index insertion-order comparison limit. Incoming native tar and outgoing transfer/transaction gates pass with zero failed transfer acknowledgments or Source body RPC bytes. Local validation includes 236 Rust tests, 236 source tests plus one platform skip, 237 compiled tests, 69 canonical model tests, 30 artifact tests and full canonical lint.

The frozen report binds production 9973ae1, native source 42d22ed4ce15160a5a9074e4b79012a99508c75c74a4a5e704443aabd86854ad and official helper 667c7f40b3eae8629d86f8b8fd7045b27cf7558b197461cbdc7135a8292ff6d4. Forty retained whole-client timing rows cover 6/518 files on tmpfs/Btrfs; median native/Node wall ratios range 0.95–1.20. No broad speedup is claimed and the switch remains opt-in.

CI is running on head efc58ab. I will merge only after every visible check is green at the final head. Snapshot/tag creation, native metadata/identity, auto-tag/dependency policies and phased local commit are already in progress in a separate worktree. The umbrella remains open; transfer does not complete the remaining snapshot or consolidated client requirements.

PR #82 is merged as 2dff93d after all 20 visible CI checks passed at efc58ab. This adds native client fetch/export transfer collection, archives and acknowledged export transactions, with file and HTTP parity, helper-failure recovery and retained whole-client measurements. The native path remains opt-in; the measurements do not establish a broad speedup. Details and limits: https://github.com/zkochan/bit/blob/efc58abfb9584937743101facc2a08b8fe0551ac/docs/rust/client-transfer.md

The next substantial chunk is snapshot/tag serialization, dependency and auto-tag policies, and acknowledged snapshot/repository orchestration. It is in progress and still requires coherent compiled CLI qualification, default framework-hook coverage and failure-prefix parity before a PR. The umbrella acceptance checklist remains open.

#266 is merged as 93bdd514ae8e78edb1aa523922edd7b0bf8292dc; its tree matches the PR head. The status/diff platform run is still in progress, so I am retaining the qualification requirement before checking its milestone off.

The next substantial chunk is the original Snapshot/tag milestone: canonical serialization/hashing, object creation, parent/history updates, refs/index updates and local commit lifecycle. Work starts from the merged master in an isolated rust-client-snapshot-tag-completion branch and will stay in one PR. Any failures in the merged status/diff platform qualification will be addressed as part of the continuing work.

Snapshot/tag milestone implementation is ready in #267 as one operation-level PR.

Rust now owns selection/cascades, semantic versions, canonical serialization/hashes, object creation, parents/history, refs/index, staged metadata, bitmap and publication. The published adapter supplies Harmony hooks/classes, issues, editor, builders and package transformations; source/artifact contents use private spools. Includes soft tags/persistence, versions files, registry retries, workspace roots, applications and Windows publication/linking.

Local qualification passed: all required lint/doc checks, 1,198 workspace tests and all 375 ported oracle cases. Five alternating fresh-copy pairs per workload passed whole stdout/stderr parity with no fallback: ordinary snap 833→295 ms, ordinary tag 860→284 ms, callback snap 867→804 ms, callback tag 875→808 ms (Node→Rust medians). Terminal colors/output/exit checks also passed. Reproducible samples/fingerprints are recorded in the PR's acceptance documentation.

The roadmap checkbox remains pending exact-head platform CI. This PR also fixes the Windows diff-path mismatch from #266 and separates remote diff setup from the pinned Node Windows repository-listing bug, with an explicit characterization test. The Status/diff checkbox likewise stays pending that Windows qualification.

#267 now includes the platform fixes found during qualification:

Portable metadata publication tests replace the obsolete macOS/Windows unsupported-platform assertion.
Windows package normalization preserves an absent types property instead of inserting null.
The published callback host runs from a private .cjs file, avoiding Windows' inline-command length limit, with session-lifetime cleanup on success/failure.
The 20 Windows diff oracles passed. Remote/lane status fixtures now use the published local export lifecycle plus canonical remote seeding around the confirmed Node Windows pending-object glob bug. Production remote acknowledgement checks remain strict.
Windows CI runs every selected oracle group and fails the job if any group fails, allowing complete failure collection.

Latest local qualification: all lint/doc checks, 1,201 workspace tests and all 376 oracle cases pass. Refreshed five-pair complete-command medians (Node→Rust): snap 865→307 ms, tag 858→318 ms, callback snap 847→804 ms, callback tag 871→795 ms. All twenty stdout/stderr pairs and terminal checks match. The committed native tree matches the measured tree recorded in scripts/rust/benchmarks/snapshot-tag.json.

Exact-head platform CI is running on bc7cf0a9218a0916e5e968526bc449229a1e6e5f: https://github.com/zkochan/bit/actions/runs/38941014754 . Milestone checkboxes remain pending that result.

Snapshot/tag milestone update: PR #267 is now at f3cc2b988424b6ce0469392b39d769100a2d380a.

The previous head passed Linux x64/ARM64, macOS Intel/ARM64, Windows workspace tests, the full Linux oracle suite, and every selected Windows oracle group except commands::tag. That group aborted without a normal test failure report. Its test registry used socket unwraps and could panic again during cleanup after a disconnected client; the fixture now handles cancelled requests, preserves the original failure, and includes a real TCP disconnect regression. Windows oracle logs now expose uncaptured failure diagnostics. No test groups were removed.

All local gates pass on this revision: formatter, Clippy, Dylint, rustdoc, 1,201 workspace tests, all 377 oracle cases, port inventory and warnings-denied release build. Fresh-copy complete-command output and actual-terminal checks pass. New five-pair medians (Node → Rust): ordinary snap 835 → 289 ms, ordinary tag 863 → 290 ms, callback snap 867 → 814 ms, callback tag 873 → 797 ms. The committed measurement record identifies the exact native source tree and raw samples.

Exact-head platform run is pending. Milestone checkboxes remain pending until it passes.

PR #267 is now at f468e2db61283ce6172f653f2d59b6d50773cdb0.

The previous platform run completed all workspace/lint jobs successfully. Windows parity passed every group except two registry tag cases. Uncaptured diagnostics isolated the test server: accepted sockets inherit nonblocking mode on Windows, so requests arriving after accept could fail with WouldBlock and be interpreted as unpublished versions. The fixture now explicitly restores blocking mode; a real TCP regression forces a nonblocking accepted socket and delayed headers. The old handler fails that regression locally; the new one passes. No product registry behavior was changed.

The Linux oracle run passed 376 of 377 cases; one autosync fixture failed while copying a disappeared file. That file was not identified by the old diagnostic and the race has not reproduced locally. Autosync setup now disables automatic Git maintenance before snapshots, and copy errors remain strict with exact source/destination paths. Three repeated autosync runs passed all 12 cases.

All local checks pass on the new revision, including all 378 oracle cases. The release binary's SHA-256 is identical to the committed benchmark record, so its complete-command parity, terminal checks and performance measurements still apply. New exact-head platform run. Checkboxes remain pending until qualification succeeds.

Completed the Snapshot/tag milestone in merged PR #267 (ff324bc041e2e71ee8affd0bb058caf211738f53). Also marked Status and diff complete after the dedicated Windows oracle passed its remaining platform qualification.

Exact-head CI: all eight Rust jobs passed, including Linux x64/ARM64, macOS Intel/ARM64, Windows workspace tests, the full Linux oracle suite and every selected Windows VCS parity group. Local qualification passed all required formatter/lint/documentation checks, 1,201 workspace tests, 378 oracle cases, inventory and warnings-denied release build. No oracle groups were removed.

Rust owns snapshot/tag selection and cascades, version allocation, canonical objects/hashes, parent/history updates, refs/index, staged metadata, bitmap and local publication. Published Harmony callbacks, class hydration, builders, package transformations and registry queries remain explicit adapters. Source/artifact bodies use private file spools. Tests cover physically compiled extensions, callback effects and publication failure prefixes.

Fresh-copy complete-command medians (Node → Rust) were snap 835 → 289 ms, tag 863 → 290 ms, callback snap 867 → 814 ms and callback tag 873 → 797 ms. Complete output and actual-terminal checks passed; callback gains remain modest. The final fixture-only changes rebuild to the same release SHA-256 as the committed measurement record. Qualification and retained boundaries.

The remaining roadmap items stay open: complete checkout/repository API, merge/history, fetch/push, and final consolidation/removal of superseded TypeScript. This completes a milestone, not the entire issue.

Starting the next original milestone: Rust repository API and complete checkout path, on rust-client-checkout-completion based on merged #267. This is one substantial completion PR.

The audit identified actual remaining operation gaps: state/glob checkout and reset selection, checkout dependency-policy updates/conflicts, workspace-root protection with full Version validation, extension lifecycle/output, native discovery of new default-scope components, and Windows/repository-layout qualification. Work is underway across these areas, with the published 2.2.94 CLI as oracle. The existing user checkout and dependency graph remain untouched.

The milestone stays unchecked until the implementation, complete-command correctness/performance measurements and platform CI qualify the final revision.

Repository/checkout milestone PR: #268. All seven required local gates passed (1,212 workspace tests, one existing ignored; 406 e2e cases), plus the warnings-denied release build. Strict complete-command checks passed all 20 timed and 20 additional TTY pairs, including exact component.json materialization. Rust medians beat Node in all four measured fixtures; samples and fingerprints are in scripts/rust/benchmarks/checkout.json.

The milestone checkbox remains open until exact-head Linux/macOS/Windows CI passes and the PR merges. Remaining checkout adapter/fallback boundaries are documented in the PR description and docs/rust-cli.md; merge/history, fetch/push and consolidation remain separate milestones.

Completed the repository/checkout milestone in #268. The exact PR head passed all ten checks: linting, workspace tests on Linux x64/ARM, macOS Intel/ARM and Windows, the full ported e2e suite, and Windows status/snapshot/checkout parity. CI: https://github.com/zkochan/bit/actions/runs/38971972859

Local qualification passed 1,215 workspace tests (one existing ignored), all 406 e2e cases and the warnings-denied release build. Twenty timed complete-command pairs and twenty additional TTY pairs matched output and exact workspace/bitmap/configuration bytes. Final measured Node/Rust medians: stored checkout 504.759/15.856 ms, reset 482.201/14.076 ms, revert 472.003/9.048 ms, compiled callbacks 539.230/521.279 ms. The callback margin is small and these are fixture-specific results. Samples, fixture hashes, helper/binary fingerprints and the measured native tree are in scripts/rust/benchmarks/checkout.json.

Remaining checkout adapter/fallback boundaries are explicit in the PR description and docs/rust-cli.md. No documentation was added under docs/rust/. Merge/history, fetch/push and consolidation remain open; the separate pending-deleted list presentation discrepancy also remains.

Started the merge/history milestone on rust-client-merge-history-completion, based on merged #268, in an isolated worktree. This is one operation-level PR covering native unrelated-history policy, removed/model-backed/hidden merge targets, merge-to-snapshot lifecycle, configured continuation/abort callbacks and recovery, and platform/history-path qualification. Existing graph and three-way merge kernels are being reused.

The CLI is moving from duplicate preview/materialization captures to a retained capture, native materialization, installation and real merge-resolution snapshot with the same provider host. Initial unrelated-history and continuation/abort oracles are passing; broader qualification and complete-command measurements are still pending. The milestone remains unchecked. No new documentation will be added under docs/rust/.

Completed the merge/history milestone in PR #269.

Rust now owns one retained merge lifecycle through component/lane planning, file and configuration publication, snapshot continuation, conflict resolution and abort. This includes removed/hidden components, unrelated and squashed history, dependency cascades, mixed conflict batches, canonical configuration conflict documents, callback/build ordering and acknowledged failure prefixes. History readers and historical checkout share the graph policy.

Validation: all seven required local gates, 1,227 unit tests, 448 end-to-end tests, a warnings-denied release build, and all exact-head Linux/macOS/Windows CI checks. The Windows matrix includes a dedicated merge/history parity group.

Complete-command medians against published Bit 2.2.94 / Node 22.22.0: callback merge 1,034 ms versus 1,100 ms; automatic merge 291 ms versus 848 ms; pending merge 276 ms versus 751 ms; history log 2.15 ms versus 263 ms. All 60 verification pairs pass across non-terminal, terminal and CI modes. Raw measurements, source/helper fingerprints and qualification details are in the benchmark record.

Documented pre-effect adapter/fallback boundaries remain, including incomplete local history closure and historical checkout that would publish an advanced remote Lane. Errors after provider/cache/publication effects stay owned by the native operation. No docs/rust/ files were added.

Remaining roadmap milestones: fetch/push orchestration and repository reconciliation; then provisioning/diagnostics/configuration consolidation and removal of superseded implementations after compatibility qualification.

Completed the fetch/push milestone in #270.

Rust owns main/lane object selection and history closures, bounded streaming transport, authentication/TLS configuration, session cancellation, acknowledgement handling and repository reconciliation. Export retains ownership through persisted models/history, package callbacks and bitmap/control publication. Default generated packages use the shared Rust linker; configured Harmony providers, callbacks and class projection remain published-CLI adapters. Supported plans and pre-effect decline boundaries are documented in rust-cli.md.

Qualification: 1,260 workspace tests and 495 complete e2e cases passed locally, followed by all twelve exact-head Rust CI checks across Linux, macOS and Windows, including all 125 cases in the new Windows transfer group. All 105 benchmark pairs matched output and state, including generated packages and links. The six workloads without configured callbacks measured 2.1–27× lower medians; configured callbacks measured 653 ms versus Node's 682 ms off a terminal; an earlier full run had effectively tied TTY medians, so no general callback speedup is claimed. Samples, source/binary fingerprints and reproduction commands retain the slower intermediate measurements too.

The remaining roadmap milestone is consolidation of provisioning, diagnostics and configuration, with removal of superseded implementations after compatibility qualification. Its checkbox remains open.

Native provisioning/configuration/diagnostics consolidation is implemented in #271, targeting rust-workspace-materialization so it feeds directly into teambit#10813. It adds native init/config/doctor, a shared configuration/JSONC/path/serialization crate, bounded repository metadata reads, exact command-history behavior and Windows provisioning parity CI.

All seven local gates pass: 1,285 workspace tests and 531 released-CLI e2e tests, plus focused export qualification. All 165 complete-command benchmark pairs matched output and state; Rust was faster in every measured mode. Full doctor measured 1.8–2.0× faster, with its fixed eight read-only checks running concurrently. Source/helper/binary/fixture fingerprints and reproduction settings are committed with the PR.

CI is running; I will merge only after all 14 PR checks succeed. The remaining TypeScript retirement requirement stays open: those implementations still serve unsupported-input fallbacks and users of the Node CLI. This PR does not remove that compatibility path or claim that #73 is fully closed.

PR #282 completes additional list/cat/reset compatibility modes. Producer cefa60c183c70720b660e6b239ecb9c4a07caf49 passes all seven native checks plus Rust scope (1,581 workspace tests, 858 e2e cases) and nine 1 MiB stack regressions. Fresh qualification passes seven complete-command workloads / 105 exact alternating comparison pairs, all native, with all 21 eligible medians lower than released Node. Cold documentation is only slightly faster. One exit-zero CPU-invalid config/all attempt is retained separately; the first-valid results were never rerun.

The 39.8 MB evidence archive was uploaded, independently downloaded/extracted and checked against every file checksum/mode and reconstructed native source. SHA-256 3e65e0b55892fc4e29f2b5df4f92ac4fd1ebce7773af7e0ea18fa7f8f21b7f14. These are warm-metadata Linux file-remote results for that exact executable, not general platform claims or qualification of later changes.

PR #282 remains draft pending a cat cache-write error correction and final-head platform CI. The changed executable will receive fresh qualification; the measurements above retain their original identity. The next substantial chunk covers remote hard deletion/lane removal, retained provider/installation sessions and mutable callbacks, authored import installation, shared-group export, unexported revert, configured-provider lane import, and remaining valid fetch/soft-tag modes. Ordinary tag-on-lane and fetch JSON are rejected by released Node; those are diagnostic boundaries rather than missing successful native operations. Shared TypeScript services still have live fallback/IDE/extension/server consumers. This issue remains open until the remaining work is validated and merged.

Navigation Menu

Repository navigation

Move the client-side VCS engine to Rust #73

Operation roadmap

Completion requirements

Initial chunk

108 remaining items

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Move the client-side VCS engine to Rust #73

Description

Operation roadmap

Completion requirements

Initial chunk

Activity

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

zkochan commented on Oct 11, 2026

108 remaining items

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 16, 2026

zkochan commented on Oct 17, 2026

zkochan commented on Oct 17, 2026

zkochan commented on Oct 17, 2026

zkochan commented on Oct 19, 2026

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions