Repository navigation
feat(engine)!: ship one native reylo binary per platform - #152
Merged
Merged
Conversation
The engine is the reylo binary (engine/cli), which reylo installs as one of eight @reylosql/engine-<platform> optional dependencies; the four WebAssembly components and the @reylosql/<database> peers are gone.
|
The latest updates on your projects. Learn more about Vercel for GitHub.
|
There was a problem hiding this comment.
🟡 Changes recommended
The SQLite fallback can produce inconsistent snapshots and expose database contents, while CLI tests omit the engine path required for subprocesses to run in clean CI environments.
4 open issues
11 files not reviewed
examples/bun/pnpm-lock.yaml: Generated fileexamples/cloudflare-workers/pnpm-lock.yaml: Generated fileexamples/esbuild/pnpm-lock.yaml: Generated fileexamples/jest/pnpm-lock.yaml: Generated fileexamples/nextjs/pnpm-lock.yaml: Generated fileexamples/node/pnpm-lock.yaml: Generated fileexamples/nub/pnpm-lock.yaml: Generated fileexamples/rspack/pnpm-lock.yaml: Generated fileexamples/vite/pnpm-lock.yaml: Generated fileexamples/webpack/pnpm-lock.yaml: Generated filepnpm-lock.yaml: Generated file
What changed in this PR
This breaking change moves Reylo’s SQL analysis from per-database WebAssembly packages to one native executable per platform, while retaining WebAssembly for the docs playground.
Changes:
- Introduces the native engine CLI, platform discovery, and updated loader integration.
- Adds platform-specific builds and release assets, including a separately distributed playground engine.
- Updates tests, SQLite behavior, documentation, and examples for the new installation model.
| File | Description |
|---|---|
| tsconfig.build.json | Includes build-time tooling and the D1 proxy. |
| tests/unterminated.test.ts | Removes database-engine package links. |
| tests/project.test.ts | Uses platform-independent engine lookup. |
| tests/project-file-module.test.ts | Removes the SQLite engine link. |
| tests/lex.test.ts | Checks asynchronous and one-shot engine lexing. |
| tests/jest.test.ts | Removes the SQLite engine link. |
| tests/fingerprint.test.ts | Removes committed-component fingerprint checks. |
| tests/engines.test.ts | Tests native discovery, validation, and connection lifecycle. |
| tests/depth.test.ts | Adapts depth checks to native execution. |
| tests/definition.test.ts | Removes the SQLite engine link. |
| tests/connect.test.ts | Adapts connection tests to native paths and execution. |
| tests/comments.test.ts | Removes database-engine package links. |
| tests/cli.test.ts | Updates stderr expectations and engine comments. |
| tests/catalog-queries.test.ts | Uses simplified engine lookup. |
| tests/analyze.test.ts | Adapts offline dialect assumptions to cached entries. |
| src/webpack.ts | Loads tooling through the new loader. |
| src/vite.ts | Loads tooling through the new loader. |
| src/tooling.ts | Updates tooling ownership and its type import. |
| src/tooling-loader.ts | Adds lazy loading of local build-time tooling. |
| src/register-worker.ts | Uses the new tooling loader. |
| src/project.ts | Infers offline dialects from cached entries. |
| src/play.ts | Awaits session lexing. |
| src/native.ts | Finds the platform package or configured executable. |
| src/mapper.ts | Uses local build-time tooling. |
| src/mapper-server.ts | Updates engine lookup and awaits lexing. |
| src/loader.ts | Awaits fallback parameter lexing. |
| src/host-url.ts | Resolves certificate paths without WASI mapping. |
| src/esbuild.ts | Uses the new tooling loader. |
| src/engine-worker.ts | Removes the WebAssembly connection worker. |
| src/engine-package.ts | Removes per-database tooling discovery. |
| src/engine-core.ts | Supports asynchronous replay requests. |
| src/duckdb.ts | Updates the engine architecture comment. |
| src/connection.ts | Updates the explanation of shared error identities. |
| src/component.ts | Removes the Node-side WASI host. |
| src/commands.ts | Updates the tooling ownership comment. |
| src/cli.ts | Loads commands through the new tooling loader. |
| src/analyze.ts | Updates engine lookup, fingerprints, and asynchronous lexing. |
| site/scripts/playground-engine.ts | Retrieves and verifies the playground engine. |
| site/scripts/capture-types.ts | Awaits session lexing during capture. |
| site/package.json | Prepares the playground engine before dev and build. |
| site/lib/root-modules.d.ts | Removes the obsolete root shim declaration. |
| site/lib/live/worker.ts | Loads WebAssembly assets from .playground. |
| site/lib/live/plugin.ts | Uses the new playground engine directory. |
| site/lib/live/play-data.ts | Reads playground assets from their new directory. |
| site/lib/live/engine.ts | Imports the prepared playground component. |
| site/lib/live/engine-dir.ts | Defines the playground asset directory. |
| site/content/sections/01-setup.mdx | Documents native requirements and installation. |
| site/content/docs/sqlite.mdx | Removes the separate engine-package reference. |
| site/content/docs/postgres.mdx | Removes the separate engine-package reference. |
| site/content/docs/mysql.mdx | Removes the separate engine-package reference. |
| site/.gitignore | Ignores prepared playground assets. |
| README.md | Simplifies installation instructions. |
| pnpm-lock.yaml | Removes old engine links and the direct shim dependency. |
| packages/sqlite/tooling.ts | Removes the SQLite tooling re-export. |
| packages/sqlite/README.md | Removes obsolete SQLite package documentation. |
| packages/sqlite/package.json | Removes the SQLite engine package manifest. |
| packages/postgres/tooling.ts | Removes the Postgres tooling re-export. |
| packages/postgres/README.md | Removes obsolete Postgres package documentation. |
| packages/postgres/package.json | Removes the Postgres engine package manifest. |
| packages/mysql/tooling.ts | Removes the MySQL tooling re-export. |
| packages/mysql/README.md | Removes obsolete MySQL package documentation. |
| packages/mysql/package.json | Removes the MySQL engine package manifest. |
| packages/duckdb/tooling.ts | Removes the DuckDB tooling re-export. |
| packages/duckdb/README.md | Removes obsolete DuckDB package documentation. |
| packages/duckdb/package.json | Removes the DuckDB engine package manifest. |
| package.json | Removes per-database engine dependencies and peers. |
| oracle/cases/sqlite_functions/unchecked.txt | Records unavailable sqlite_offset cases. |
| oracle/cases/sqlite_functions/offset_missing.sql | Adds an unavailable-function projection case. |
| oracle/cases/sqlite_functions/offset_missing_in_where.sql | Adds an unavailable-function filter case. |
| oracle/cases/sqlite_functions/math.sql | Covers enabled SQLite math functions. |
| oracle/cases/sqlite_functions/math_in_where.sql | Covers math functions in filters. |
| oracle/cases/sqlite_functions/expected.txt | Updates SQLite function expectations. |
| npm/platforms.json | Defines eight platform targets and runners. |
| npm/engine/README.md | Adds platform-package documentation. |
| lab/nextjs/tsconfig.json | Raises the compilation target to ES2020. |
| lab/nextjs/README.md | Documents native engine setup. |
| lab/jest/README.md | Documents native engine setup. |
| lab/bundlers/README.md | Documents checkout binary discovery. |
| examples/webpack/README.md | < 8000 td>Updates installation and engine explanations.|
| examples/webpack/pnpm-lock.yaml | Removes the MySQL engine link. |
| examples/webpack/package.json | Removes the MySQL engine dependency. |
| examples/vite/README.md | Updates installation and engine explanations. |
| examples/vite/pnpm-lock.yaml | Removes the Postgres engine link. |
| examples/vite/package.json | Removes the Postgres engine dependency. |
| examples/rspack/README.md | Updates installation and engine explanations. |
| examples/rspack/pnpm-lock.yaml | Removes the Postgres engine link. |
| examples/rspack/package.json | Removes the Postgres engine dependency. |
| examples/README.md | Explains building and linking native platform packages. |
| examples/nub/README.md | Updates installation and engine explanations. |
| examples/nub/pnpm-lock.yaml | Removes the SQLite engine link. |
| examples/nub/package.json | Removes the SQLite engine dependency. |
| examples/node/README.md | Updates installation and engine explanations. |
| examples/node/pnpm-lock.yaml | Removes the Postgres engine link. |
| examples/node/package.json | Removes the Postgres engine dependency. |
| examples/nextjs/README.md | Updates installation and engine explanations. |
| examples/nextjs/pnpm-lock.yaml | Removes the Postgres engine link. |
| examples/nextjs/package.json | Removes the Postgres engine dependency. |
| examples/jest/README.md | Updates installation and engine explanations. |
| examples/jest/pnpm-lock.yaml | Removes the SQLite engine link. |
| examples/jest/package.json | Removes the SQLite engine dependency. |
| examples/esbuild/README.md | Updates installation and bundle explanations. |
| examples/esbuild/pnpm-lock.yaml | Removes the Postgres engine link. |
| examples/esbuild/package.json | Removes the Postgres engine dependency. |
| examples/cloudflare-workers/README.md | Updates installation and engine explanations. |
| examples/cloudflare-workers/pnpm-lock.yaml | Removes the SQLite engine link. |
| examples/cloudflare-workers/package.json | Removes the SQLite engine dependency. |
| examples/bun/README.md | Updates installation and engine explanations. |
| examples/bun/pnpm-lock.yaml | Removes the SQLite engine link. |
| examples/bun/package.json | Removes the SQLite engine dependency. |
| engine/wasip2/src/lib.rs | Updates the WebAssembly host documentation. |
| engine/wasip2/Cargo.toml | Documents the component’s playground role. |
| engine/wasip2/Cargo.lock | Updates the core crate version. |
| engine/README.md | Documents native architecture and build commands. |
| engine/native/src/sqlite.rs | Adds a copy fallback for locked databases. |
| engine/native/src/lib.rs | Exposes serving with an explicit one-shot mode. |
| engine/core/Cargo.toml | Inherits the workspace version. |
| engine/cli/src/main.rs | Adds database dispatch and version commands. |
| engine/cli/Cargo.toml | Defines the native executable crate. |
| engine/build.sh | Builds WebAssembly only for the playground. |
| Cargo.toml | Registers the CLI and shared version. |
| Cargo.lock | Records the CLI and updated core version. |
| .github/workflows/windows.yml | Builds and supplies the Windows executable. |
| .github/workflows/test.yml | Adds native binary and playground build jobs. |
| .github/workflows/release.yml | Builds, stages, and releases platform assets. |
| .github/scripts/windows-check.ts | Removes per-database package dependencies. |
| .github/scripts/npm-stage-publish.sh | Updates platform-package comments. |
| .github/scripts/build-playground.sh | Builds and archives the playground component. |
| .github/scripts/build-binary.sh | Builds and smoke-checks platform executables. |
| .cargo/config.toml | Enables additional bundled SQLite functions. |
Review effort: Balanced
Comment on lines
+142
to
+145
| let dir = std::env::temp_dir().join(format!("reylo-sqlite-{}-{:016x}", std::process::id(), hasher.finish())); | ||
| let copy = dir.join("db"); | ||
| let failed = |e: std::io::Error| rusqlite::Error::SqliteFailure(rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_CANTOPEN), Some(format!("cannot copy the database the app holds: {e}"))); | ||
| std::fs::create_dir_all(&dir).map_err(failed)?; |
Owner
Author
There was a problem hiding this comment.
Fixed: the copies now go in a directory the program creates itself, refusing one that already exists, so no directory or link someone else put there is written through. It is owner-only on Unix, belongs to the connection, and is removed when the connection closes or the engine exits. A Rust test covers the copy, its mode and its removal.
Comment on lines
+149
to
+152
| std::fs::copy(path, ©).map_err(failed)?; | ||
| let wal = format!("{path}-wal"); | ||
| if std::path::Path::new(&wal).exists() { | ||
| std::fs::copy(&wal, dir.join("db-wal")).map_err(failed)?; |
Owner
Author
There was a problem hiding this comment.
Fixed: the log is copied after the file, and the snapshot is kept only when the log's header (its checkpoint sequence and salts) is the same before the file's copy, in the copy and after it. A checkpoint that restarted the log in between retakes both. A checkpoint that only writes the file is safe, since the log still holds every page it wrote.
Comment on lines
184
to
185
| // The engine is the preload's worker's child, whose stderr is the program's own. | ||
| const r = spawnSync(process.execPath, ["--import", pathToFileURL(REGISTER).href, "main.ts"], { cwd: root, encoding: "utf8", env: { PATH: process.env.PATH, DATABASE_URL: "file:./app.db" } }); |
Owner
Author
There was a problem hiding this comment.
Right: CI names the binary only in REYLO_ENGINE_PATH. The three spawns now pass it through when it is set; the run with no URL still leaves DATABASE_URL out.
Comment on lines
+142
to
+145
| let dir = std::env::temp_dir().join(format!("reylo-sqlite-{}-{:016x}", std::process::id(), hasher.finish())); | ||
| let copy = dir.join("db"); | ||
| let failed = |e: std::io::Error| rusqlite::Error::SqliteFailure(rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_CANTOPEN), Some(format!("cannot copy the database the app holds: {e}"))); | ||
| std::fs::create_dir_all(&dir).map_err(failed)?; |
Owner
Author
There was a problem hiding this comment.
Fixed: the copies now go in a directory the program creates itself, refusing one that already exists, so no directory or link someone else put there is written through. It is owner-only on Unix, belongs to the connection, and is removed when the connection closes or the engine exits. A Rust test covers the copy, its mode and its removal.
Contributor
There was a problem hiding this comment.
ℹ️ No critical issues — three rough edges inline, and a few stale references below.
Reviewed changes
I reviewed the whole PR: the engine moves from four committed WebAssembly components to one native reylo binary, published as one npm package per platform.
- Native binary:
engine/cliservesreylo engine <database> [call]overengine/native's JSON-lines protocol.reylo --versionand the ping report the Cargo workspace's version, which must equalpackage.json's. - Loader host:
src/engine.tsruns one long-lived child per database and one child per connection. The children are unreferenced, and a timer keeps the process alive while a request waits. Syncconfiggoes throughspawnSync.src/native.tsfinds the binary:REYLO_ENGINE_PATH, then the platform package, then a checkout'starget/. - Build-time half:
src/tooling-loader.tsreplacessrc/engine-package.ts.dist/reylonow ships the tsc-compiledtooling.jsgraph. I checked it: it has no bare imports and no top-level await, sorequirestill loads it. - No URL, no engine package: where no URL names the dialect, it now comes from the
dialectrecorded in the.reylo/queriesentries. - Packaging:
scripts/build.tswritesdist/engine-<platform>and lists all eight packages asoptionalDependencies. It checks each binary's ELF, Mach-O or PE header against its package'sos/cpu/libc. It links the host's engine intodist/reylo/node_modules. - SQLite natively:
.cargo/config.tomlenables the math, percentile and geopoly functions for every native build, and the oracle case is updated to match. A file another process holds locked (Turso) is read through a temp copy. - CI and release: test.yml gets a
binaryjob feedingREYLO_ENGINE_PATHand aplaygroundwasm job. release.yml builds the binary on each platform's own runner, stages eight platform packages beforereylo, and attaches tarballs, the playground engine andSHA256SUMSto the GitHub release before it movesrelease. - Docs site: the playground engine comes from
site/.playground/, filled bysite/scripts/playground-engine.tsfrom the checkout's build or the release asset, after a hash check.
ℹ️ Stale references to the per-database packages, and a scope gap for .cargo/
Several files outside the diff still describe the removed @reylosql/<database> packages. One new file is also not covered by CI's scope. These lines aren't in the diff, so they're listed here.
Technical details
# Stale engine-package references and CI scope
## Affected sites
- `engine/postgres/src/lib.rs:8`, `engine/mysql/src/lib.rs:7`, `engine/sqlite/src/lib.rs:7`: crate docs say the WebAssembly component "the package `@reylosql/<db>` carries".
- `engine/native/src/bin/reylo-{postgres,mysql,sqlite,duckdb}.rs:1`: "`@reylosql/<db>`'s engine as a native program". Nothing ships these per-database binaries any more; `reylo engine <db>` replaces them.
- `Cargo.toml:5`: "`reylo-engine-native`, the program each database's WebAssembly component is built from". `Cargo.toml:39-41` still describes "the engine's components".
- `.github/workflows/test.yml:63` (the `everything` regex in `scope`): `.cargo/` is not listed. A PR that changes `.cargo/config.toml` changes the SQLite every native build compiles, yet it would run neither the engine's tests nor the oracle.
## Required outcome
- Comments describe the `reylo` binary and the platform packages.
- A change under `.cargo/` runs every engine check.
## Open questions for the human
- Should the `reylo-<db>` bins in `engine/native/Cargo.toml` stay, for example for the oracle or ad hoc use, or go?claude-opus-5-5 ｜ 𝕏
Pass REYLO_ENGINE_PATH to the CLI tests' children, keep a held SQLite file's copies in a private directory removed with its connection, check a stale binary against its sources' fingerprint, and load wasi-sdk's own libclang and clang for the playground's bindings.
Owner
Author
|
On the review's list: the crate docs, the per-database programs' docs and the workspace comment now describe the |
Contributor
There was a problem hiding this comment.
Important
The Windows check now crashes on its first run() call, before it checks anything. Because the windows job is skipped on pull requests, this shows up only after the merge, on the push to main.
Reviewed changes
I reviewed a99f766, which answers the initial review and makes the playground build on Linux.
- SQLite copies of a held file: the copies now go in a directory that
Copies::createmakes itself. It refuses a path that already exists, is0o700on Unix, and is removed onDropwhen the connection closes.open_copynow copies the WAL after the file and retries when the log's header changed in between. A Rust test covers the copy, its mode and its removal. - Stale-binary guard:
tests/fingerprint.test.tsis back. It hashesengine/coreand each database crate's sources and compares the result with the fingerprint the binary's ping reports. - Engine lookup in CI:
windows-check.tsremovesREYLO_ENGINE_PATHfrom its children's environment, sodist/reylohas to find the engine through the platform-package junction.tests/cli.test.tsnow passesREYLO_ENGINE_PATHthrough to its children. - CI scope: the
everythingregex in test.yml's scope now includes.cargo/. - Playground on Linux:
engine/build.shpoints bindgen at wasi-sdk's ownlibclangandclang. - Stale references: the doc comments in the engine crates, the
reylo-<db>bins,Cargo.tomlandengine/README.mdnow describe thereylobinary.
claude-opus-5-5 ｜ 𝕏
binaries.yml builds the eight binaries (release.yml now calls it), then installs reylo from them on each platform and types and runs a query. The glibc builds run in manylinux_2_28. Also: copy a held file's journal and reuse its copy, settle an id-less answer, and word comments without unreleased products.
Contributor
There was a problem hiding this comment.
ℹ️ No critical issues. One minor suggestion inline, on the new SQLite copy cache.
Reviewed changes
I reviewed 859e4ca, which installs and runs each platform's binary on that platform and builds the Linux binaries for glibc 2.28.
binaries.yml: added a workflow that release.yml calls as itsbuildjob and that also runs on pull requests touching the binary. It builds each platform's binary, packs all nine packages, then installs and runs them on each platform. Linux runs in several images: Debian 11, AlmaLinux 8, Amazon Linux 2 10BC8 023 and Alpine.install-check.tsandwith-node.sh: added a check that publishes the packed packages to a local Verdaccio registry. It installsreyloin a fresh project, confirms npm brought only this platform's engine, runsreylo generateand the preload on SQLite, and checks Postgres's nesting depth limit against the installed binary.- glibc 2.28: linux-gnu is now built in pinned manylinux_2_28 containers, and
build-binary.shfails if the binary needs a glibc symbol newer than 2.28. The SQLite flags now come only from.cargo/config.toml. - SQLite copy of a held file: the copy now includes the rollback journal as well as the WAL. It is reused while the file and its logs keep the same size and modification time. A new test covers rolling back a hot journal.
- Loader:
scripts/build.tschecks thatPLATFORM_PACKAGESmatchesnpm/platforms.jsonandrequires the builttooling.js.Channelmatches an answer with noidto the oldest pending request (the engine answers in order). The checkout fallback picks the newer oftarget/releaseandtarget/debug. windows-check.ts:environmentis now declared before the firstrun(), which fixes the module-scope TDZ crash.- Engine docs: the comments in
engine/coreandengine/postgresno longer mention Reylo Framework or thereyloextension; they now say "a host" and "a server-side extension".
claude-opus-5-5 ｜ 𝕏
A file written within the last second may be written again in the same clock tick with the same size, so its copy is not reused. Also: find the Windows runner's MySQL wherever its version put it, and leave the install check's files to the runner where Windows still holds them.
Contributor
There was a problem hiding this comment.
✅ No new issues found. The racy-stamp concern on the SQLite copy cache is addressed.
Reviewed changes
I reviewed 5ced853, which keeps a held SQLite file's copy only after the file has settled, and fixes two things in Windows CI.
- SQLite copy cache:
open_copynow readsnowbefore it takes the stamp. It keeps the stamp only when every file in it was last modified at least a second beforenow, which is git's rule for a racy index entry. A same-size write in the same clock tick therefore forces a fresh copy. If any file has no modification time, the copy is never kept, which is the safe default. The journal test now covers both a fresh write (copy not kept) and a settled one (copy kept and reused). - Windows MySQL:
windows.ymlnow findsmysqld.exeunder whatever versioned directory the runner image has, instead of the hard-codedMySQL Server 8.0path. If it finds no server, the step fails and lists what is there.AGENTS.mdno longer pins the version. - Install check cleanup:
install-check.tsnow ignores an error fromrmSyncin itsfinallyblock. On Windows, the engine's child processes still hold their files open until the process exits.
claude-opus-5-5 ｜ 𝕏
The native engine checked sslrootcert=system against the operating system's store alone. A chain it refuses is now checked as Node checks one, against the roots NODE_EXTRA_CA_CERTS names.
Contributor
There was a problem hiding this comment.
ℹ️ No critical issues. One minor edge case inline, in the new handling of
NODE_EXTRA_CA_CERTS.
Reviewed changes
I reviewed 1ccbe22. It makes the native engine trust the roots named by NODE_EXTRA_CA_CERTS as well as the operating system's store.
OrExtraverifier: when no root file is named, the native engine still checks the chain with the operating system first. If the system refuses it, the engine checks the chain again with webpki against the extra roots. When that check finds no extra root either (UnknownIssuer), the user sees the system's original error, so a chain to a public CA reports the same failure as before. Both verifiers use the sameringprovider, so sending the handshake-signature checks toextramakes no difference.extra_roots(): one helper now reads the extra roots for both the native engine and the WebAssembly engine. The WebAssembly engine still adds them on top of webpki-roots. The loader already passes this variable to the engine, resolved to an absolute path (engineEnvinsrc/engine.ts).
claude-opus-5-5 ｜ 𝕏
Contributor
There was a problem hiding this comment.
✅ No new issues found. The empty
NODE_EXTRA_CA_CERTSstore case is handled.
Reviewed changes
I reviewed e11b136, which keeps the system's roots when NODE_EXTRA_CA_CERTS holds no usable root.
- Empty extra-roots store: in
engine/native/src/tls.rs, if none of the file's certificates could be added to theRootCertStore, the native verifier is now the operating system's verifier alone. It no longer builds aWebPkiServerVerifierover an empty store, which returnedNoRootAnchorsand made every connection fail. This matches Node, which warns about such a file and continues without it.
claude-opus-5-5 ｜ 𝕏
This was referenced Nov 3, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Reylo's engine becomes one native program, the
reylobinary, built for eight platforms and installed throughreylo's optional dependencies, in place of the four WebAssembly components committed underpackages/.What changes
engine/cli(cratereylo) serves each database's engine asreylo engine <database>, the JSON-lines protocolengine/nativespeaks, orreylo engine <database> callfor one request;reylo --versionprints reylo's version, which the Cargo workspace now carries ([workspace.package]) and the ping reports.src/engine.tsruns the binary as a long-lived child per database (the ping, the lexer, DuckDB's replay) and one child per connection, held only while a request waits so a build still exits.src/native.tsfinds it:REYLO_ENGINE_PATH, else the platform package reylo's install holds, else a checkout'starget/releaseortarget/debug.src/component.ts,src/engine-worker.ts,src/engine-package.tsandtests/fingerprint.test.tsare gone;src/tooling-loader.tsloads the build-time half.dist/reylolists@reylosql/engine-<platform>for darwin-arm64, darwin-x64, linux-x64, linux-x64-musl, linux-arm64, linux-arm64-musl, win32-x64 and win32-arm64 as optional dependencies at its exact version (npm/platforms.json), and no longer has the@reylosql/<database>peers.scripts/build.tswritesdist/engine-<platform>and refuses a binary whose header names another platform, or a version that differs from package.json's.packages/is deleted: no engine is committed.binaries.ymlbuilds the binary for each of the eight platforms on its own runner, Linux on glibc in a pinnedmanylinux_2_28container so that it starts on glibc 2.28 (build-binary.shrefuses a newer symbol), packs the nine packages, and on each platform installsreylofrom a registry of its own into a fresh project (.github/scripts/install-check.ts): npm must bring that platform's engine alone, which types a query withreylo generate, runs it under the preload, and reads Postgres statements nested to the engine's bound. Linux on glibc runs it in Debian 11, AlmaLinux 8 and Amazon Linux 2023, on musl in Alpine, macOS on Intel on an Intel runner. It runs on pull requests that change the binary or its packaging, and within each release, which now calls it for its build.test.yml: abinaryjob builds the binary once and hands it to the loader's tests; aplaygroundjob builds the docs site's WebAssembly playground engine on a pull request that changes Postgres's engine or anything shared, so a brokenwasm32-wasip2build fails before a release does.release.yml: the binary is built on each platform's own runner (.github/scripts/build-binary.sh, which checks--versionand a ping on all four databases), the eight platform packages are staged before reylo, and the GitHub release carries the binaries, the playground engine andSHA256SUMS.site/scripts/playground-engine.ts, checked againstSHA256SUMS), or from a checkout's ownengine/build.shoutput, instead of frompackages/postgres.sslrootcert=system, a chain the operating system refuses is checked against the rootsNODE_EXTRA_CA_CERTSnames, as Node checks it; the WebAssembly engine already did..cargo/config.toml), and a SQLite file another engine holds locked (Turso's) is read through a copy instead of waiting. The WebAssembly engines already behaved this way.README.md,AGENTS.mdandengine/README.mdfollow.Upgrading
"dependencies": { "reylo": "^0.7.0" }, "devDependencies": { - "@reylosql/postgres": "^0.6.0", "typescript": "beta" }A production install that runs the
reylo/registerpreload needs the engine: keepreyloa dependency, and install without--omit=optional.Time to the first analysis
macOS arm64, three runs each, from importing
src/engine.tsto the firstanalyze("select 1 as x")::memory:)Verified
On every platform, by
binaries.ymlon e11b136: all eight binaries built, and each installed, typed and ran a query. On Windows x64, bywindows.ymlrun by hand on this branch: the loader's tests, the type check through every form a Windows path takes, Postgres's TLS files andNODE_EXTRA_CA_CERTS, MySQL over a named pipe, and the Node example. The Windows job now finds the runner's MySQL wherever its image version puts it;main's Windows job had been failing since the image moved it.On macOS arm64:
nub run typecheck;nub run testwith Postgres 18 and MySQL 8.4, none skipped.cargo build --workspace --all-targetswith no warning;cargo testof every crate; the oracle with--strict-coverage(DuckDB's cases with--features duckdb) and SQLite's own test suite replayed against the engine.nub run build(dist/reyloanddist/engine-darwin-arm64), the docs site's build, the playground engine's WebAssembly build and its ping, ten labs and all ten examples, each on the built packages.actionlintandshellcheckon the changed workflows and scripts.Until a release carries the playground asset, Vercel's preview builds of
maincannot fetch the playground engine; reylo.dev serves thereleasebranch and is unaffected.