alkgit-substrate 0.1.0

The shipped alkgit backend composition: the reactive alkstore + alkblobs backend implementing alkgit's backend seam — reactive halves, cached read provider, engine twins, migrations, GC wiring, and the LFS surface (ADR-019/025)
Documentation
# Two-member workspace (ADR-025): this crate is the shipped backend
# composition; the protocol core is the root package (`alkgit`).
# The feature set is ADR-025's placement table.
#
# The package shape (the family package policy — the core's
# w5-release-readiness precedent; no `exclude` entries needed): the
# member directory contains only what ships — this manifest, `src/`,
# `tests/` (the working assembly rows are the crate's documentation of
# its own behavior), the crate-level `README.md`/`CHANGELOG.md`, and
# the family's LICENSE files (copied into the member — a workspace
# member packages only its own directory; the authoritative
# architecture docs live in the repo root's `docs/` and are referenced
# from the README). No scratch material, no task/process surface
# ships.
[package]
name = "alkgit-substrate"
version = "0.1.0"
edition = "2021"
rust-version = "1.88"
license = "MIT OR Apache-2.0"
repository = "https://git.alk.dev/alkdev/alkgit"
description = "The shipped alkgit backend composition: the reactive alkstore + alkblobs backend implementing alkgit's backend seam — reactive halves, cached read provider, engine twins, migrations, GC wiring, and the LFS surface (ADR-019/025)"
keywords = ["git", "protocol", "alkcall", "vcs", "database"]
categories = ["network-programming", "asynchronous", "database"]

[features]
default = ["sqlite", "lfs"]
# The sqlite co-tenant registry/ref twin (concrete tables + connections).
sqlite = ["dep:alkstore-sqlite", "dep:rusqlite"]
# The postgres twin.
postgres = ["dep:alkstore-postgres", "dep:tokio-postgres", "alkblobs/postgres"]
# The LFS surface (ADR-022) — on by default (fail-safe default, ADR-022 §6).
# The enablement is the wave-6-flagged decision landing (the wave-6
# manifest read's record, below): the reactive halves consume nothing
# from alkblobs' alkcall surface, but the LFS byte paths (the batch's
# ops control plane and the put custody's mint/confirm verbs) do —
# `alkblobs/ops` plus the direct alkcall pin ride the feature. The pin
# is the same 0.10 family pin the core's manifest carries (the
# composition's wire-layer family pin).
lfs = ["dep:alkcall", "alkblobs/ops"]

[dependencies]
# The seam contract: alkgit's backend traits + seam types. Inter-crate pin
# is by version; the path is the workspace-internal member (ADR-025 — the
# only path dependency either manifest carries). The version pin is
# version-enforced — never a bare sibling-checkout path.
alkgit = { path = "..", version = "0.1.0" }
# The reactive halves ride the unconditional deps (alkstore's core trait +
# alkblobs) — base, not a feature (ADR-025). Published-crates pins
# (backend.md §crate and feature model): alkstore family 0.1, alkblobs 0.2
# (resolving to 0.2.2, the review-013-fixed release — the version alkblobs'
# `ops` gate names). The wave-6 manifest read's record, resolved by the
# wave-9 manifest enablement: the reactive halves are alkstore machinery
# and consume nothing from alkblobs' alkcall surface — the `ops`
# enablement lands in wave 9 under the `lfs` feature, whose LFS byte
# paths (pre-keyed put / ranged fetch) ride alkblobs' marked-pub-put
# contract (alkblobs ADR-014); the batch/checking adapter answers over
# `blobs/stat` through the ops control plane (ADR-022 §2).
alkstore = "0.1"
alkblobs = "0.2"
# The LFS surface's direct alkcall pin (`lfs` feature — the ops control
# plane's OperationContext/registry machinery the adapter builds; the
# same 0.10 family pin the core carries; alkblobs' `ops` gate resolves
# the same crate).
alkcall = { version = "0.10", optional = true }
# The announce composition's payload `Value` (alkstore's trait
# signatures pin serde_json::Value — the trait-surface type the
# reactor serializes `RegistryEvent`/`MaintenanceJob` through). Same
# "1" pin as the core's manifest.
serde_json = "1"
serde = { version = "1", features = ["derive"] }
# Engine twins (alkblob-style features of this crate, ADR-025).
alkstore-sqlite = { version = "0.1", optional = true }
alkstore-postgres = { version = "0.1", optional = true }
# The postgres twin's co-tenant connection driver — the same family
# pin alkstore-postgres carries (0.7); the twin's SQL and the stamp
# runner ride it directly (the engine re-exports nothing of it).
tokio-postgres = { version = "0.7", optional = true }
# The co-tenant connection surface (the migrations handle + the twins'
# concrete SQL ride rusqlite directly — the same pin alkstore-sqlite
# carries; `bundled` is inherited from the engine twin's enablement and
# declared here so the co-tenant handle stands alone in its feature).
rusqlite = { version = "0.40", features = ["bundled"], optional = true }
# The packaging toolkit (pack generation/ingest pipelines, ADR-020 §2).
# gix-odb is deliberately absent — no on-disk odb engine is shipped
# (ADR-019); objects flow through alkblobs. The feature set matches the
# core crate's pipeline dev-dependency pin (ADR-004's composition).
gix-pack = { version = "0.76", default-features = false, features = [
    "generate",
    "parallel",
    "sha1",
    "streaming-input",
] }
# The object model (kinds, loose headers, refs) — the odb front and the
# pack pipelines' shared vocabulary. The gix-fsck pin stays the wave-8
# ingestion pre-commitment (unmoved; review-004 R-1's posture).
gix-object = { version = "0.66", features = ["sha1"] }
gix-fsck = { version = "0.27", features = ["sha1"] }
# ADR-004's commit-ancestry walk (the two-stage closure's stage two).
gix-traverse = { version = "0.63", features = ["sha1"] }
# The pack pipeline's chunked-entry stage (InOrderIter — ADR-004).
gix-parallel = { version = "0.50", default-features = false, features = ["parallel"] }
# The pipeline's progress plumbing (Discard) + compression level type.
gix-utils = { version = "0.5", features = ["progress"] }
gix-zlib = { version = "0.3" }
# The through-store shape's request digest + mid-flight slice-digest
# re-derivation (sha2 — the same family pin alkblobs carries).
sha2 = "0.10"
# Ref-name validation at the refs table layer (substrate.md §refs:
# ADR-013 §7's `gix_validate::reference` usage moves from gix-ref files
# to the table layer — the `gix-ref` pin the wave-6 manifest read killed;
# refs are rows, ADR-019 §2). Same version family as the core's pin.
gix-validate = "0.13"
# The gix Find trait signatures' error family (find_traits return
# gix_error::Result; the odb front's impls name the type).
gix-error = "0.5"
# The refs rows' oids ([`RefLine`] carries gix oids) — the core's
# gix-hash family pin (same version, sha1 default per OQ-05).
gix-hash = { version = "0.28", features = ["sha1"] }
async-trait = "0.1"
# `rt-multi-thread` is the block_in_place posture's floor (the odb
# front's async-context bridge half and the eventual liveness source).
tokio = { version = "1", default-features = false, features = ["rt", "rt-multi-thread", "sync", "io-util", "macros", "time", "fs"] }
parking_lot = "0.12"
# No `tracing` dependency — the family's no-log-dep precedent (alkblobs
# review 001 S-4, the core's review-004 D-1): none of the stub-dead crate
# logs, and a future telemetry pass would be a deliberate feature.
thiserror = "2"

[dev-dependencies]
# The mem engine — the reactor suite's base engine column (the
# engine-generic reactive composition's completeness leg; the sqlite
# column rides the `sqlite` feature's own engine dependency).
alkstore-mem = "0.1"
# The pipeline toolkit is a real dependency now (the wave-7 packgen
# promotion — this file's [dependencies]); the odb.rs generation smoke
# rides those features directly.
# The odb front's git-interop vectors (git's loose-object oids) decode
# through lower-case-hex; the test suite also drives a real `git
# hash-object` when one is installed.
hex = "0.4"
tokio = { version = "1", features = ["full", "test-util", "macros"] }
# The rider rows compose the core crate's published serving machines
# (`serve_duplex` / `serve_stateless_post`): the entry tuple's identity
# type rides alkcall (the same pin the core carries), the stateless
# body's `BodyReader` reads a futures stream of `bytes`.
alkcall = "0.10"
futures = "0.3"
bytes = "1"