rubydb 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c9eda84a67f7461880366d67d049e384b92d16735bfa453c8ab580ed4394c86
-  data.tar.gz: 577ab7b7758ebfbf4fa6ccbdd3fc6bc6ca022ab47253acc025fd55cdfe6935da
+  metadata.gz: 643bd199d601eaacf6a2b0488799bc651a25198c4cd204ec61b80cd8242f735b
+  data.tar.gz: fe4f88a9a9570bbefb4f157cfef080e3f67d0828988f512d74df0a91d4564625
 SHA512:
-  metadata.gz: 301264ede8f046b3d5cb2c8c3fa90d220ae184dc4a72bca0962144876702d3b2a11ab570afd8acd786893cde098df8241fd7b95bfc6f1f5d2958dee4b7c4ae5a
-  data.tar.gz: 8ec1f26484273234980dd643b040a14d500f9551a1a873f3d293d3dc089b743b3e449f134c77083ad534045cd38ebcd7f98eb0f7770b6cc38283d4b87b69bdf1
+  metadata.gz: 0f7a162c3df6d920a4f3826350d734419e6c77c8e4fcfa922171781dec37e4f48f3522c39bcff899ab489a56f21e4846ee608b3854444a6015c9de33c252d139
+  data.tar.gz: 643496af38ce2a262e8cd78c237b71df396a5eac3f376a21b7ec37f26c79c5d4c83a7c0d2b4e3f8c9acb51ba8f1f0f187bdf96fc3be74e5b97d2787e6d85a1d1

data/.gitignore

@@ -36,6 +36,10 @@
 /adapters/python/build/
 /adapters/python/dist/
 /adapters/python/src/*.egg-info/
+/adapters/rubydb/dist/
+/adapters/rubydb/node_modules/
+/examples/sveltekit_app/node_modules/
+/examples/sveltekit_app/.svelte-kit/
 __pycache__/
 *.py[cod]
 

data/CHANGELOG.md

@@ -23,6 +23,20 @@ All notable changes to RubyDB are documented here. Versions follow
   vacuum, maintenance, and release workflows.
 - Clarified the tested common SQLite-style profile and production limits.
 
+## 0.1.6 - 2026-09-18
+
+- Bundled the Go accelerator binaries and Ruby bridge for release installs;
+  developers do not need Go installed to use the packaged core gem.
+- Added lock-protected direct storage snapshots, worker lifecycle recovery,
+  multiplexed requests, cancellation, bounded execution, and adaptive Ruby/Go
+  selection with a safe Ruby fallback.
+- Added accelerator CLI diagnostics, environment-mode handling, checksums,
+  extracted-gem verification, and release packaging for the runtime binaries.
+- Added the Rails ecommerce pressure example and expanded production guidance
+  for embedded development, managed RubyDB services, PostgreSQL-backed large
+  applications, and ActiveRecord adapter deployment.
+- Prepared `rubydb-activerecord` 0.1.3 for the RubyDB 0.1.x release line.
+
 ## 0.1.5 - 2026-09-10
 
 - Applied network query and prepared-statement parameters through the server

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubydb (0.1.5)
+    rubydb (0.1.6)
       base64 (>= 0.2)
       bigdecimal (>= 3.1)
       concurrent-ruby (>= 1.2)

data/README.md

@@ -1,249 +1,318 @@
-# RubyDB
-
-RubyDB is a Ruby-native relational database with an embedded engine, a
-client/server mode, a Ruby client, and an ActiveRecord adapter.
-
-**Author:** Aldane Hutchinson
-
-> **Status: alpha.** RubyDB is suitable for experimentation, development,
-> controlled embedded workloads, and production microservices that stay within
-> the documented and tested feature set. RubyDB can be used in both development
-> and production, but each production workload must pass its own query,
-> concurrency, backup, restore, security, and operational validation. It
-> provides a tested common SQLite-style profile, but is not a drop-in
-> replacement for PostgreSQL, MySQL, or SQLite.
-
-## Recommended database roles
-
-Use RubyDB when you want a Ruby-native database for local development, tests,
-internal tools, or an independently owned microservice with a bounded workload.
-Use embedded mode when one Ruby process owns the database file. Use RubyDB
-server/client mode when multiple application processes connect to one service.
-
+# RubyDB
+
+RubyDB is a Ruby-native relational database with an embedded engine, a
+client/server mode, a Ruby client, and an ActiveRecord adapter.
+
+**Author:** Aldane Hutchinson
+
+> **Status: alpha.** RubyDB is suitable for experimentation, development,
+> controlled embedded workloads, and production microservices that stay within
+> the documented and tested feature set. RubyDB can be used in both development
+> and production, but each production workload must pass its own query,
+> concurrency, backup, restore, security, and operational validation. It
+> provides a tested common SQLite-style profile, but is not a drop-in
+> replacement for PostgreSQL, MySQL, or SQLite.
+
+## Recommended database roles
+
+Use RubyDB when you want a Ruby-native database for local development, tests,
+internal tools, or an independently owned microservice with a bounded workload.
+Use embedded mode when one Ruby process owns the database file. Use RubyDB
+server/client mode when multiple application processes connect to one service.
+
 Use PostgreSQL as the default system of record for massive applications,
 high-concurrency public products, large shared Rails applications, advanced
 PostgreSQL SQL/extensions, and workloads requiring a mature managed database
 ecosystem. A common production architecture is PostgreSQL for the main app and
 RubyDB for smaller, independently operated microservices.
 
-## What works today
-
-The repository contains implementation and automated coverage for:
-
-- SQL tables, CRUD, joins, grouping and aggregates, ordering, transactions,
-  savepoints, conflict handling, and documented maintenance statements
-- typed values, primary/foreign keys, unique and check constraints, and B-tree
-  indexes
-- durable storage, WAL-backed commits, recovery, snapshots, branching, and
-  MVCC paths
-- Ruby API, client/server protocol, connection pooling, configuration, and
-  operational tooling
-- ActiveRecord integration, Rails migrations, and a runnable Rails example
-
-These features are not a guarantee of compatibility with every application.
-Run the test suite and validate your own schema, queries, workload, backup,
-restore, and failure scenarios before using RubyDB for important data.
-
-## Why “complete PostgreSQL/MySQL/SQLite compatibility” matters
-
-That requirement is only necessary when RubyDB is intended to be a drop-in
-replacement for an existing application using one of those databases.
-
-It includes much more than accepting similar `SELECT` statements:
-
-- dialect-specific SQL syntax, functions, operators, casts, and error behavior
-- query semantics for joins, `NULL`, ordering, grouping, subqueries, CTEs,
-  unions, upserts, and window functions
-- data types, indexes, constraints, generated values, and transaction behavior
-- migration behavior and ActiveRecord adapter mappings
-- client protocol, connection behavior, locking, limits, and operational tools
-
-A new Ruby or Rails application does not need complete compatibility. It can
-use RubyDB's documented SQL and adapter behavior directly. Compatibility is
-needed to move an existing PostgreSQL, MySQL, or SQLite application without
-rewriting queries and without discovering semantic differences in production.
-
-RubyDB currently targets a documented RubyDB SQL subset plus tested Rails
-operations. The compatibility documents describe the supported statements;
-unsupported or unverified dialect features must not be assumed to work.
-
-## Quick start
-
-Install the prerelease gem:
+## Ecosystem and community adapters
+
+RubyDB's ecosystem is built around a clear boundary: application code connects
+to a RubyDB server through the documented client/server protocol. The embedded
+`.rdb` file format is an internal storage implementation, not a public API for
+third-party drivers. This lets RubyDB evolve its storage safely while language
+and framework communities build clients that share the same server behavior.
+
+Official integration surfaces include:
+
+- Ruby's direct API and the `rubydb` client/server client
+- `rubydb-activerecord` for Rails applications
+- `rubydb-python` for Python DB-API 2.0 applications
+- `rubydb-node` for Node.js and TypeScript applications
+- Sequel and other Ruby integrations documented under `adapters/`
+
+Community developers can create adapters for another language, framework,
+ORM, query builder, migration tool, observability system, or job framework.
+Every adapter should begin with the [server protocol](docs/server/protocol.md)
+and the executable protocol tests, then provide an idiomatic API for its
+community. A production adapter must preserve parameter binding, transaction
+ownership, deadlines and wire cancellation, TLS verification, bounded frames,
+error details, and clean connection shutdown. A wrapper that only sends a
+string of SQL is not a production adapter.
+
+Use a distinct package name such as `rubydb-go`, `rubydb-django`, or
+`@your-scope/rubydb` and make its ownership clear. Do not present a community
+package as an official RubyDB release. Add the adapter to the ecosystem list
+only after it has live integration tests against a real RubyDB server and its
+supported RubyDB versions are documented. The complete build, test, security,
+and publishing workflow is in
+[Lesson 11: Build a community adapter](lessons/11-community-adapter.md).
+
+## What works today
+
+The repository contains implementation and automated coverage for:
+
+- SQL tables, CRUD, joins, grouping and aggregates, ordering, transactions,
+  savepoints, conflict handling, and documented maintenance statements
+- typed values, primary/foreign keys, unique and check constraints, and B-tree
+  indexes
+- durable storage, WAL-backed commits, recovery, snapshots, branching, and
+  MVCC paths
+- Ruby API, client/server protocol, connection pooling, configuration, and
+  operational tooling
+- ActiveRecord integration, Rails migrations, and a runnable Rails example
+
+These features are not a guarantee of compatibility with every application.
+Run the test suite and validate your own schema, queries, workload, backup,
+restore, and failure scenarios before using RubyDB for important data.
+
+## Why “complete PostgreSQL/MySQL/SQLite compatibility” matters
+
+That requirement is only necessary when RubyDB is intended to be a drop-in
+replacement for an existing application using one of those databases.
+
+It includes much more than accepting similar `SELECT` statements:
+
+- dialect-specific SQL syntax, functions, operators, casts, and error behavior
+- query semantics for joins, `NULL`, ordering, grouping, subqueries, CTEs,
+  unions, upserts, and window functions
+- data types, indexes, constraints, generated values, and transaction behavior
+- migration behavior and ActiveRecord adapter mappings
+- client protocol, connection behavior, locking, limits, and operational tools
+
+A new Ruby or Rails application does not need complete compatibility. It can
+use RubyDB's documented SQL and adapter behavior directly. Compatibility is
+needed to move an existing PostgreSQL, MySQL, or SQLite application without
+rewriting queries and without discovering semantic differences in production.
+
+RubyDB currently targets a documented RubyDB SQL subset plus tested Rails
+operations. The compatibility documents describe the supported statements;
+unsupported or unverified dialect features must not be assumed to work.
+
+## Quick start
+
+Install the core release gem:
 
 ```sh
-gem install rubydb --pre
+gem install rubydb -v 0.1.6
 ```
 
-For local development from this repository:
-
-```sh
-bundle install
-bundle exec rspec
-```
-
-## Ruby usage
-
-RubyDB can run embedded in a single owning process:
-
-```ruby
-require "rubydb"
-
-engine = RubyDB::Storage::Engine.new("tmp/example.rdb")
-engine.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL)")
-engine.execute("INSERT INTO users (name) VALUES ('Aldane')")
-puts engine.execute("SELECT * FROM users").inspect
-engine.close
-```
-
-For multiple application processes, use RubyDB's server/client mode and point
-clients at the managed server. Do not open the same embedded database path
-from multiple independent processes. A regular Ruby application can use a
-RubyDB connection URL supplied by its environment:
-
-```ruby
-client = RubyDB::Client::Client.new(url: ENV.fetch("RUBYDB_URL"))
-client.query("SELECT 1")
-client.disconnect
-```
-
-Use the `rubydb://` or TLS-enabled `rubydbs://` format documented in the Rails
-configuration guide. RubyDB URLs are not PostgreSQL URLs.
-
-## Copy-and-paste examples
-
-### RubyDB for local development
-
-This creates a durable local database in one owning Ruby process:
-
-```ruby
-require "rubydb"
-
-engine = RubyDB::Storage::Engine.new("tmp/development.rdb")
-begin
-  engine.execute("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, body TEXT NOT NULL)")
-  engine.execute("INSERT INTO notes (body) VALUES ('First note')")
-  puts engine.execute("SELECT id, body FROM notes ORDER BY id").inspect
-ensure
-  engine.close
-end
-```
-
-Do not open the same embedded path from separate web and worker processes.
-
-### RubyDB for a production microservice
-
-Run one RubyDB server on persistent storage and inject a TLS URL into the
-service:
-
-```sh
-gem install rubydb -v 0.1.5
-rubydb --config /etc/rubydb/production.yml --env production start
-```
-
-```ruby
-require "rubydb"
-
-client = RubyDB::Client::Client.new(url: ENV.fetch("RUBYDB_URL"))
-begin
-  puts client.query("SELECT 1").to_hash
-ensure
-  client.disconnect
-end
-```
-
-Use a URL such as `rubydbs://user:URL_ENCODED_PASSWORD@db.internal:7432/app`
-with TLS verification enabled. Store the complete URL in a secret manager and
-keep the database service on a private network.
-
-### PostgreSQL for a massive Rails application
-
-Use the `pg` gem and a managed PostgreSQL connection string for the main
-application:
+For Rails, install the core and ActiveRecord adapter together:
 
 ```ruby
 # Gemfile
-gem "pg"
+gem "rubydb", "~> 0.1.6"
+gem "rubydb-activerecord", "~> 0.1.3"
 ```
 
-```yaml
-# config/database.yml
-production:
-  url: <%= ENV.fetch("DATABASE_URL") %>
-  pool: <%= ENV.fetch("RAILS_MAX_THREADS", "5") %>
+RubyDB ships the Go accelerator binaries inside the core gem. Developers and
+deployments do not install Go. The default `accelerator.mode: auto` starts Go
+for eligible workloads and keeps it only when the result is equivalent and
+the measured latency wins; use `RUBYDB_ACCELERATOR=required` for a readiness
+check that must exercise Go, or `RUBYDB_ACCELERATOR=off` for Ruby-only
+diagnostics.
+
+For local development from this repository:
+
+```sh
+bundle install
+bundle exec rspec
 ```
 
-Set `DATABASE_URL` through the hosting provider’s secret settings, run
-migrations once from a release job, and validate the application against the
-same PostgreSQL major version used in production.
+### Bundled Go acceleration
 
-## Rails example
-
-The small Rails 7.2 application in
-[`examples/rails_app`](examples/rails_app) runs a real migration, model query,
-and browser form through `rubydb-activerecord`.
+RubyDB keeps the Ruby engine as its correctness authority and automatically
+starts a bundled, CGO-free Go worker for proven read-only pipelines, checksums,
+and compression. The release gem contains platform binaries; end users do not
+install or configure Go. From a source checkout, build and verify the worker
+with:
 
 ```sh
-cd examples/rails_app
-bundle install
-bundle exec ruby bin/rails db:migrate
-bundle exec ruby bin/rails server -b 127.0.0.1 -p 3001
+ruby scripts/build_accelerator
+ruby -Ilib exe/rubydb accelerator --ping --json
 ```
 
-Open <http://127.0.0.1:3001/>. The example uses an embedded database under
-`tmp/`; set `RUBYDB_DATABASE` to choose another path. See the adapter and Rails
-documentation for network configuration, migrations, production deployment,
-backups, restore drills, and monitoring.
-
-For an even smaller end-to-end smoke test, see the tiny GitHub-style app in
-[`examples/github_clone`](examples/github_clone). It covers repositories,
-issues, commits, Rails associations, foreign keys, indexes, seed data, and a
-browser page backed by RubyDB.
-
-## Compatibility policy
-
-RubyDB does not claim complete PostgreSQL, MySQL, or SQLite compatibility until
-each compatibility area has both an implementation and repeatable validation.
-The project must validate at least:
-
-1. parser and execution behavior for the documented dialect surface
-2. type, constraint, transaction, locking, and error semantics
-3. ActiveRecord queries, joins, eager loading, associations, and migrations
-4. sustained concurrency, cancellation, recovery, backup/restore, and failover
-5. supported Ruby, Rails, operating-system, and client/server combinations
-
-Until then, compatibility should be treated as feature-specific, not implied
-by the presence of an adapter.
-
-## Documentation
-
-- [Documentation index](docs/README.md)
-- [Ten-lesson production journey](lessons/01-foundations.md)
-- [Developer guide](docs/developer-guide.md)
-- [Troubleshooting guide](docs/troubleshooting.md)
-- [Debugging playbook](docs/debugging.md)
-- [Production operations guide](docs/operations/production-guide.md)
-- [Lessons learned](docs/lessons-learned.md)
-- [Getting started](docs/getting-started/quickstart.md)
-- [Local development to production](docs/getting-started/local-to-production.md)
-- [SQL compatibility](docs/sql/compatibility.md)
-- [SQL compatibility guide](docs/sql/compatibility-guide.md)
-- [SQLite compatibility profile](docs/sql/sqlite-compatibility.md)
-- [SQL syntax](docs/sql/syntax.md)
-- [Rails installation](docs/rails/installation.md)
-- [Rails production guidance](docs/rails/production.md)
-- [Rails compatibility guide](docs/rails/compatibility-guide.md)
-- [Python adapter](adapters/python/README.md)
-- [Production readiness](docs/production-readiness.md)
-- [Operations and workload testing](docs/operations/workload-testing.md)
-- [Production runbook](docs/operations/production-runbook.md)
-- [CLI guide](docs/cli.md)
-- [CLI cheat sheet](docs/cli-cheatsheet.md)
-- [Release checklist](docs/release.md)
-- [Security policy](SECURITY.md)
-- [Contributing and testing](CONTRIBUTING.md)
-- [Roadmap](ROADMAP.md)
-
-## License
-
-RubyDB is released under the [MIT License](LICENSE).
+Use `accelerator.mode: off` or `RUBYDB_ACCELERATOR=off` for Ruby-only
+diagnostics. `mode: auto` calibrates eligible scans, aggregates, and inner
+hash joins against Ruby and keeps Go only when it wins without changing the
+result. Use `required` only for differential validation and readiness checks.
+See [the accelerator architecture](docs/architecture/go-accelerator.md)
+for the protocol boundary, fallback behavior, differential testing, and
+release rules.
+
+## Ruby usage
+
+RubyDB can run embedded in a single owning process:
+
+```ruby
+require "rubydb"
+
+engine = RubyDB::Storage::Engine.new("tmp/example.rdb")
+engine.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL)")
+engine.execute("INSERT INTO users (name) VALUES ('Aldane')")
+puts engine.execute("SELECT * FROM users").inspect
+engine.close
+```
+
+For multiple application processes, use RubyDB's server/client mode and point
+clients at the managed server. Do not open the same embedded database path
+from multiple independent processes. A regular Ruby application can use a
+RubyDB connection URL supplied by its environment:
+
+```ruby
+client = RubyDB::Client::Client.new(url: ENV.fetch("RUBYDB_URL"))
+client.query("SELECT 1")
+client.disconnect
+```
+
+Use the `rubydb://` or TLS-enabled `rubydbs://` format documented in the Rails
+configuration guide. RubyDB URLs are not PostgreSQL URLs.
+
+## Copy-and-paste examples
+
+### RubyDB for local development
+
+This creates a durable local database in one owning Ruby process:
+
+```ruby
+require "rubydb"
+
+engine = RubyDB::Storage::Engine.new("tmp/development.rdb")
+begin
+  engine.execute("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, body TEXT NOT NULL)")
+  engine.execute("INSERT INTO notes (body) VALUES ('First note')")
+  puts engine.execute("SELECT id, body FROM notes ORDER BY id").inspect
+ensure
+  engine.close
+end
+```
+
+Do not open the same embedded path from separate web and worker processes.
+
+### RubyDB for a production microservice
+
+Run one RubyDB server on persistent storage and inject a TLS URL into the
+service:
+
+```sh
+gem install rubydb -v 0.1.6
+rubydb --config /etc/rubydb/production.yml --env production start
+```
+
+```ruby
+require "rubydb"
+
+client = RubyDB::Client::Client.new(url: ENV.fetch("RUBYDB_URL"))
+begin
+  puts client.query("SELECT 1").to_hash
+ensure
+  client.disconnect
+end
+```
+
+Use a URL such as `rubydbs://user:URL_ENCODED_PASSWORD@db.internal:7432/app`
+with TLS verification enabled. Store the complete URL in a secret manager and
+keep the database service on a private network.
+
+### PostgreSQL for a massive Rails application
+
+Use the `pg` gem and a managed PostgreSQL connection string for the main
+application:
+
+```ruby
+# Gemfile
+gem "pg"
+```
+
+```yaml
+# config/database.yml
+production:
+  url: <%= ENV.fetch("DATABASE_URL") %>
+  pool: <%= ENV.fetch("RAILS_MAX_THREADS", "5") %>
+```
+
+Set `DATABASE_URL` through the hosting provider’s secret settings, run
+migrations once from a release job, and validate the application against the
+same PostgreSQL major version used in production.
+
+## Rails example
+
+The small Rails 7.2 application in
+[`examples/rails_app`](examples/rails_app) runs a real migration, model query,
+and browser form through `rubydb-activerecord`.
+
+```sh
+cd examples/rails_app
+bundle install
+bundle exec ruby bin/rails db:migrate
+bundle exec ruby bin/rails server -b 127.0.0.1 -p 3001
+```
+
+Open <http://127.0.0.1:3001/>. The example uses an embedded database under
+`tmp/`; set `RUBYDB_DATABASE` to choose another path. See the adapter and Rails
+documentation for network configuration, migrations, production deployment,
+backups, restore drills, and monitoring.
+
+For an even smaller end-to-end smoke test, see the tiny GitHub-style app in
+[`examples/github_clone`](examples/github_clone). It covers repositories,
+issues, commits, Rails associations, foreign keys, indexes, seed data, and a
+browser page backed by RubyDB.
+
+## Compatibility policy
+
+RubyDB does not claim complete PostgreSQL, MySQL, or SQLite compatibility until
+each compatibility area has both an implementation and repeatable validation.
+The project must validate at least:
+
+1. parser and execution behavior for the documented dialect surface
+2. type, constraint, transaction, locking, and error semantics
+3. ActiveRecord queries, joins, eager loading, associations, and migrations
+4. sustained concurrency, cancellation, recovery, backup/restore, and failover
+5. supported Ruby, Rails, operating-system, and client/server combinations
+
+Until then, compatibility should be treated as feature-specific, not implied
+by the presence of an adapter.
+
+## Documentation
+
+- [Documentation index](docs/README.md)
+- [Production journey](lessons/01-foundations.md)
+- [Developer guide](docs/developer-guide.md)
+- [Troubleshooting guide](docs/troubleshooting.md)
+- [Debugging playbook](docs/debugging.md)
+- [Production operations guide](docs/operations/production-guide.md)
+- [Lessons learned](docs/lessons-learned.md)
+- [Getting started](docs/getting-started/quickstart.md)
+- [Local development to production](docs/getting-started/local-to-production.md)
+- [SQL compatibility](docs/sql/compatibility.md)
+- [SQL compatibility guide](docs/sql/compatibility-guide.md)
+- [SQLite compatibility profile](docs/sql/sqlite-compatibility.md)
+- [SQL syntax](docs/sql/syntax.md)
+- [Rails installation](docs/rails/installation.md)
+- [Rails production guidance](docs/rails/production.md)
+- [Rails compatibility guide](docs/rails/compatibility-guide.md)
+- [Python adapter](adapters/python/README.md)
+- [Production readiness](docs/production-readiness.md)
+- [Operations and workload testing](docs/operations/workload-testing.md)
+- [Production runbook](docs/operations/production-runbook.md)
+- [CLI guide](docs/cli.md)
+- [CLI cheat sheet](docs/cli-cheatsheet.md)
+- [Release checklist](docs/release.md)
+- [Security policy](SECURITY.md)
+- [Contributing and testing](CONTRIBUTING.md)
+- [Roadmap](ROADMAP.md)
+
+## License
+
+RubyDB is released under the [MIT License](LICENSE).

data/Rakefile

@@ -11,8 +11,13 @@ RSpec::Core::RakeTask.new(:spec)
 task default: %i[spec rubocop]
 
 namespace :build do
+  desc "Build the bundled Go accelerator for the current platform"
+  task :accelerator do
+    abort "Go accelerator build failed" unless system({"RUBYDB_ACCELERATOR_TARGETS" => "current"}, RbConfig.ruby, "scripts/build_accelerator")
+  end
+
   desc "Build the gem and write a SHA-512 checksum for the exact artifact"
-  task checksum: :build do
+  task checksum: [:accelerator, :build] do
     gem_path = Dir["pkg/rubydb-*.gem"].max_by { |path| File.mtime(path) }
     abort "No built gem found in pkg/" unless gem_path
 

data/accelerator/bin/SHA256SUMS

@@ -0,0 +1,6 @@
+ceeaad8692cfdc0e7b72b85d2c17b5e23c754d5f1159590df142fcfa857b8ff3  rubydb-accelerator-darwin-amd64
+1ab2ca6b7294f7d97ff4e816a5ad504802e84e4c196146a199a145a74829e3a0  rubydb-accelerator-darwin-arm64
+a0d141e3c41f2709d5bbaa67dd856f28805e4c2cbbc1034826e190877aa05aad  rubydb-accelerator-linux-amd64
+445b164c71284ce6432215fcf1213a99497194b3c8da6ea9577602405de4cf38  rubydb-accelerator-linux-arm64
+9e5c4f9acc9fe9751d5c945956fdbec50f9c698a2b5a0366255edef700a1499d  rubydb-accelerator-windows-amd64.exe
+3dd6aa97761f00a4552fa21a16571598bdfef8850347202ee4131d88ee97d002  rubydb-accelerator-windows-arm64.exe