picovolt 2.3.0

Embedded SQL database with MVCC history and single-file deployment
Documentation
# Current distribution policy

PicoVolt 2.3.0 uses free public-source proprietary terms, not Apache-2.0.
Run `python scripts/check_public_release.py` before publishing. The gate checks
`legal/PUBLIC-RELEASE.json`, its version, zero fee, terms digest and binding copies.
No engine account or clickwrap service is required. Binary packages must carry
licenses, dependency notices and the release notice; the macOS wheel metadata
must pass `scripts/check_macos_wheel.py`. Earlier Apache grants remain intact.
See [2.3 verification](RELEASE_2_3.md) for the current release evidence.

# Release cadence

PicoVolt runs a fast release train: one backward-compatible minor-release window
each UTC day and one major-release window each ISO week. Patch releases ship as
soon as a security, data-integrity, or urgent regression fix is ready. These are
release opportunities, not permission to mint empty versions: Semantic
Versioning determines the number, and the candidate gates below determine
whether a release is eligible.

## Stable release checklist

1. Triage open regressions and update `CHANGELOG.md`.
2. Run the complete Rust, WASM, Go, Python, npm, CLI, and benchmark smoke matrix.
   For format releases, run the golden migration corpus and the scheduled
   fuzz/model/recovery soak workflow as well.
3. Confirm the committed root `Cargo.lock` is current and the package version is
   identical in Cargo, Python, npm, the Go module
   tag, and native version output.
4. Tag an annotated `vX.Y.Z` release.
5. Verify crates.io, npm, PyPI, `proxy.golang.org`, native binaries, C ABI
   bundles, SBOMs, checksums, and attestations.
6. Run clean-install starter tests and record download totals after 24 hours.

Release candidates may be published before a stable cut when ecosystem testing
would add useful evidence. Published `.pvdb` format compatibility is covered by
the golden fixture suite.

The 1.9 stabilization gate additionally requires:

- migration of every checked-in 1.x golden image with matching full-history
  verification hashes and transaction-by-transaction results;
- a clean scheduled fuzz shard for every parser/decoder target and a clean model
  plus abrupt-process recovery shard;
- all seven machine-readable performance budgets (open, scan, point lookup,
  top-N, join, bake, and recovery open) below their shared-runner ceilings;
- no unresolved critical or high-severity security finding.

For 1.9 and later releases, qualification is evidence-based and scoped to the
exact candidate; there is no minimum elapsed-time wait. A candidate must have a
green golden migration corpus, fuzz/model/recovery evidence, all seven
performance budgets, zero unresolved critical/high findings, and compatibility
evidence appropriate to the changed surfaces. Before publication, the complete
first-party cross-language and browser matrix is accepted candidate evidence;
after publication, exact registry clean installs are mandatory before the
GitHub Release is created. A candidate change invalidates only the evidence it
can affect; fix and rerun any failed gate before tagging.
GitHub-hosted jobs are bounded shards, not a claim of uninterrupted execution;
longer runs require a dedicated runner and should retain their logs and fuzz
artifacts. The current candidate, decisions, evidence, and remaining gates are
tracked in the [1.9.0 qualification ledger](RELEASE_1_9_SOAK.md).

Native release binaries include `data-tools` (Parquet, SQLite, and dataset
signing). Source installs opt in with `cargo install picovolt --features
data-tools`; npm and Python do not bundle these CLI dependencies. Release
verification runs `cargo test --locked --all-targets --all-features`, including
the public-dataset differential gate and corruption/resume/signature checks in
`tests/data_movement.rs`, `tests/data_inspection.rs`, `tests/migration.rs`, and
`tests/stabilization.rs`.

## Registry-only starter gate

Every pull request checks that the Rust, Node, browser, Python, and Go starters
pin the same version as `Cargo.toml` and contain no Cargo path dependency, npm
`file:`/`link:` dependency, editable Python requirement, or Go `replace`
directive. The policy also requires registry-backed SHA-512 npm lock entries,
Go module checksums, Cargo/Python/module version parity, and a byte-identical Go
copy of the public C header:

```sh
python scripts/check_registry_starters.py policy
python -m unittest discover -s scripts/tests -v
```

On a release tag, CI copies each starter to an isolated temporary directory,
installs that exact version, verifies its resolved package origin, and executes
it. Rust comes from crates.io, Node and browser from npm, and Python from PyPI.
The Go wrapper and ABI header come from `proxy.golang.org`; because it uses cgo,
its matching native library is taken from the PyPI wheel during the clean-room
gate. After PyPI publishing succeeds, the Python wheels workflow idempotently
creates the required `bindings/go/vX.Y.Z` submodule tag and then tests both
registries. The main release workflow waits for that exact tag workflow as well
as its crates.io/npm gate before it creates the GitHub Release. A failed or
missing registry therefore cannot leave a nominally complete GitHub Release.

The Go proxy can cache a missing revision even after its tag is visible on
GitHub. The next-release workflow allows a bounded forty-minute download retry
window, with fifty minutes for the containing install job and sixty minutes for
the release's dependent gate. A timeout remains a failure; rerun only failed
jobs once the proxy has caught up. Never move a published tag to clear a cache.

The smoke runner starts each package manager with an allowlisted environment:
local registry/proxy settings, language search paths, dynamic-loader overrides,
and inherited credentials are removed. Ignored build output is also excluded
when a starter is copied. No test is allowed to reach into this checkout's
`bindings/`, `target/`, or root Cargo package.

Each GitHub Release contains CLI/server executables, SBOMs, checksums, and a
`picovolt-capi-<platform>.tar.gz` bundle with the matching shared library and
`include/picovolt.h`. Release creation is the final gate, after the package
registries and provenance-attested native artifacts have succeeded.
Both workflows serialize runs per tag. Publishing steps detect immutable
artifacts that already exist, so a rerun resumes safely; an unpublished crate
with no Cargo credential is a failure, never a silent skip.
The release compiler and `wasm-pack` version are pinned, Cargo commands use the
committed lockfile, and build paths are remapped out of the npm WebAssembly
binary so a pre-release package checksum can be reproduced on Linux.
When building through WSL, pack from a native Linux filesystem with regular
package files set to mode 0644. Windows-mounted files can appear executable;
those permission bits change npm tarball integrity even when contents match.
The hosted npm-package gate must reproduce the committed starter integrity.

After public artifacts exist, the same checks can be reproduced locally (the Go
native test currently requires Linux):

```sh
python scripts/check_registry_starters.py run --starter rust --starter node
python scripts/check_registry_starters.py run --starter browser --starter python
python scripts/check_registry_starters.py run --starter go
```