sqlrite 0.1.8__tar.gz → 0.1.10__tar.gz

{sqlrite-0.1.8 → sqlrite-0.1.10}/.github/workflows/release.yml

@@ -9,7 +9,9 @@
 # Phase 6f adds build-python-wheels + publish-python.
 # Phase 6g adds build-nodejs-binaries + publish-nodejs.
 # Phase 6h adds publish-wasm.
-# Phase 6i adds publish-go.
+# Phase 6i adds publish-go (no registry — git tag + GitHub Release
+# with the FFI tarballs attached for users who want prebuilt
+# libsqlrite_c alongside `go get`).
 #
 # Design doc: docs/release-plan.md.
 # One-time registry / branch-protection setup: docs/release-secrets.md.
@@ -128,6 +130,7 @@ jobs:
             "sqlrite-py-v$V"
             "sqlrite-node-v$V"
             "sqlrite-wasm-v$V"
+            "sdk/go/v$V"
             "v$V"
           )
           for tag in "${TAGS[@]}"; do
@@ -1074,6 +1077,144 @@ jobs:
           files: sdk/wasm/pkg/*.wasm
           generate_release_notes: true
 
+  # ---------------------------------------------------------------------------
+  # Step 3i: publish the Go SDK. (Phase 6i.)
+  #
+  # Go's distribution model is unique among our publish channels:
+  # there's NO central registry. Go modules pull straight from VCS
+  # via tag, and `go get github.com/joaoh82/rust_sqlite/sdk/go@v0.X.Y`
+  # works the moment a `sdk/go/v0.X.Y` tag is on the remote (modulo
+  # ~minutes of cache lag at proxy.golang.org). The tag is created
+  # by `tag-all` upstream of this job — there's nothing to upload.
+  #
+  # **What this job DOES do:** the binding uses cgo against
+  # `libsqlrite_c` (the C FFI from sqlrite-ffi), so end users
+  # need that shared library on their system to run anything.
+  # We pull the per-platform tarballs that publish-ffi already
+  # uploaded to its release and re-attach them to the Go release
+  # page so Go users have a one-stop-shop:
+  #
+  #   `go get github.com/joaoh82/rust_sqlite/sdk/go@vX.Y.Z`
+  #   download `libsqlrite_c-<platform>.tar.gz` from the same
+  #   release page → set CGO_LDFLAGS / CGO_CFLAGS → `go build`.
+  #
+  # **Tag with slashes:** Go's submodule tag convention is
+  # `<subpath>/vX.Y.Z` — for our module path
+  # `github.com/joaoh82/rust_sqlite/sdk/go`, the canonical tag is
+  # `sdk/go/vX.Y.Z` (slashes intact). GitHub Releases handle
+  # slash-bearing tags fine; the URL just URL-encodes them.
+  publish-go:
+    name: Publish Go SDK GitHub Release
+    needs: [detect, tag-all, publish-ffi]
+    if: needs.detect.outputs.should_release == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      # For softprops/action-gh-release + gh CLI release-download.
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Need full tag history to verify tag-all's `sdk/go/v$V`
+          # is on the remote.
+          fetch-depth: 0
+
+      # Cheap consistency check that tag-all did its job. If this
+      # fires, something's wrong upstream and the human should
+      # know before we cut a confusingly-named GitHub Release.
+      - name: Verify Go module tag exists
+        run: |
+          V="${{ needs.detect.outputs.version }}"
+          TAG="sdk/go/v$V"
+          if ! git rev-parse "$TAG" >/dev/null 2>&1; then
+            echo "::error::Tag $TAG not found — tag-all should have created + pushed it"
+            exit 1
+          fi
+          echo "Tag $TAG exists at $(git rev-parse --short $TAG)"
+
+      # Pull the tarballs publish-ffi already attached to the
+      # sqlrite-ffi-v<V> release. The `gh release download` flow
+      # avoids re-running the whole publish-ffi build matrix just
+      # to get the artifacts here — it's a single API call with
+      # the workflow's auto-injected GITHUB_TOKEN.
+      - name: Download FFI tarballs from this release wave
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          V="${{ needs.detect.outputs.version }}"
+          mkdir -p ffi-tarballs
+          gh release download "sqlrite-ffi-v$V" \
+            --repo joaoh82/rust_sqlite \
+            --dir ffi-tarballs \
+            --pattern '*.tar.gz'
+          echo "--- FFI tarballs downloaded ---"
+          ls -la ffi-tarballs/
+
+      # Cut the Go release page. Tag has slashes — softprops handles
+      # that correctly (URL-encodes the slashes in the resulting
+      # release URL).
+      - name: GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: sdk/go/v${{ needs.detect.outputs.version }}
+          name: Go SDK v${{ needs.detect.outputs.version }}
+          body: |
+            ```bash
+            go get github.com/joaoh82/rust_sqlite/sdk/go@v${{ needs.detect.outputs.version }}
+            ```
+
+            ```go
+            package main
+
+            import (
+                "database/sql"
+                "fmt"
+
+                _ "github.com/joaoh82/rust_sqlite/sdk/go"  // registers "sqlrite" driver
+            )
+
+            func main() {
+                db, _ := sql.Open("sqlrite", ":memory:")
+                defer db.Close()
+
+                _, _ = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
+                _, _ = db.Exec("INSERT INTO users (name) VALUES ('alice')")
+
+                rows, _ := db.Query("SELECT id, name FROM users")
+                defer rows.Close()
+                for rows.Next() {
+                    var id int64
+                    var name string
+                    rows.Scan(&id, &name)
+                    fmt.Printf("%d: %s\n", id, name)
+                }
+            }
+            ```
+
+            ## Prebuilt `libsqlrite_c` (cgo dependency)
+
+            The Go binding uses cgo against the `libsqlrite_c` shared library shipped by [`sqlrite-ffi`](https://github.com/joaoh82/rust_sqlite/tree/main/sqlrite-ffi). The tarballs attached below are the same ones from this release wave's [C FFI release](../../releases/tag/sqlrite-ffi-v${{ needs.detect.outputs.version }}) — provided here so Go users have a one-stop-shop:
+
+            - `sqlrite-ffi-v${{ needs.detect.outputs.version }}-linux-x86_64.tar.gz`
+            - `sqlrite-ffi-v${{ needs.detect.outputs.version }}-linux-aarch64.tar.gz`
+            - `sqlrite-ffi-v${{ needs.detect.outputs.version }}-macos-aarch64.tar.gz`
+            - `sqlrite-ffi-v${{ needs.detect.outputs.version }}-windows-x86_64.tar.gz`
+
+            Extract for your platform, then point cgo at it:
+
+            ```bash
+            tar xzf sqlrite-ffi-v${{ needs.detect.outputs.version }}-<platform>.tar.gz
+            export CGO_CFLAGS="-I$(pwd)/sqlrite-ffi-v${{ needs.detect.outputs.version }}-<platform>/include"
+            export CGO_LDFLAGS="-L$(pwd)/sqlrite-ffi-v${{ needs.detect.outputs.version }}-<platform>/lib -lsqlrite_c"
+            export LD_LIBRARY_PATH="$(pwd)/sqlrite-ffi-v${{ needs.detect.outputs.version }}-<platform>/lib"
+            go build ./...
+            ```
+
+            (On macOS use `DYLD_LIBRARY_PATH` instead of `LD_LIBRARY_PATH`. On Windows, place the `.dll` next to your binary or on `%PATH%`.)
+
+            See the umbrella release [v${{ needs.detect.outputs.version }}](../../releases/tag/v${{ needs.detect.outputs.version }}) for the full changelog.
+          files: ffi-tarballs/*.tar.gz
+          generate_release_notes: true
+
   # ---------------------------------------------------------------------------
   # Step 4: create the umbrella GitHub Release. Runs after all
   # publish-* jobs succeed. Uses GitHub's native auto-generated
@@ -1082,7 +1223,7 @@ jobs:
   # config if we add one later.
   finalize:
     name: Finalize umbrella release
-    needs: [detect, publish-crate, publish-ffi, publish-desktop, publish-python, publish-nodejs, publish-wasm]
+    needs: [detect, publish-crate, publish-ffi, publish-desktop, publish-python, publish-nodejs, publish-wasm, publish-go]
     if: needs.detect.outputs.should_release == 'true'
     runs-on: ubuntu-latest
     steps:
@@ -1106,8 +1247,7 @@ jobs:
             - 🐍 [Python](../../releases/tag/sqlrite-py-v${{ needs.detect.outputs.version }}) → [PyPI](https://pypi.org/project/sqlrite/${{ needs.detect.outputs.version }}/) — abi3-py38 wheels for Linux x86_64/aarch64, macOS aarch64, Windows x86_64 + sdist
             - 🟢 [Node.js](../../releases/tag/sqlrite-node-v${{ needs.detect.outputs.version }}) → [npm](https://www.npmjs.com/package/@joaoh82/sqlrite/v/${{ needs.detect.outputs.version }}) — N-API bindings with prebuilt `.node` binaries for Linux x86_64/aarch64, macOS aarch64, Windows x86_64
             - 🌐 [WASM](../../releases/tag/sqlrite-wasm-v${{ needs.detect.outputs.version }}) → [npm](https://www.npmjs.com/package/@joaoh82/sqlrite-wasm/v/${{ needs.detect.outputs.version }}) — browser/bundler-target WebAssembly build via wasm-pack
-
-            _Go SDK lands as its publish job comes online (Phase 6i)._
+            - 🐹 [Go SDK](../../releases/tag/sdk%2Fgo%2Fv${{ needs.detect.outputs.version }}) → `go get github.com/joaoh82/rust_sqlite/sdk/go@v${{ needs.detect.outputs.version }}` — `database/sql` driver via cgo against `libsqlrite_c`
 
             ---
 

{sqlrite-0.1.8 → sqlrite-0.1.10}/Cargo.lock

@@ -3736,7 +3736,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-desktop"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "serde",
  "serde_json",
@@ -3748,7 +3748,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-engine"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "clap",
  "env_logger",
@@ -3763,7 +3763,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ffi"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "cbindgen",
  "sqlrite-engine",
@@ -3771,7 +3771,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-nodejs"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "napi",
  "napi-build",
@@ -3781,7 +3781,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-python"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "pyo3",
  "sqlrite-engine",

{sqlrite-0.1.8 → sqlrite-0.1.10}/Cargo.toml

@@ -27,7 +27,7 @@ resolver = "3"
 # `package =` key so the import name stays `sqlrite` internally:
 #     sqlrite = { package = "sqlrite-engine", path = "…" }
 name = "sqlrite-engine"
-version = "0.1.8"
+version = "0.1.10"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.1.8 → sqlrite-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrite
-Version: 0.1.8
+Version: 0.1.10
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -30,7 +30,7 @@ Python bindings for [SQLRite](https://github.com/joaoh82/rust_sqlite) — a smal
 ## Install
 
 ```bash
-# From PyPI (once Phase 6e's CI/CD release pipeline is live):
+# From PyPI:
 pip install sqlrite
 
 # From source in a clone of the repo:
@@ -125,7 +125,7 @@ python -m pytest tests/
 
 - PyO3 (`abi3-py38`) for the Rust-Python boundary — one wheel works on every CPython 3.8+ release, no per-version rebuild.
 - maturin as the build backend, emitting standard `.whl` files that pip can install directly.
-- Phase 6e lands GitHub Actions that publish wheels to PyPI for manylinux x86_64/aarch64, macOS universal, and Windows x86_64 on every `v*` tag push.
+- Phase 6f's CI publishes abi3-py38 wheels to PyPI for manylinux x86_64/aarch64, macOS aarch64, and Windows x86_64 (plus an sdist) on every release. OIDC trusted publishing — no long-lived PyPI token in the repo.
 
 ## Status
 

{sqlrite-0.1.8 → sqlrite-0.1.10}/README.md

@@ -29,8 +29,8 @@ Rust-SQLite (SQLRite)
         <td><a href="https://github.com/sponsors/joaoh82"><img src="https://img.shields.io/opencollective/backers/sqlrite"></a></td>
       </tr>
       <tr>
-        <td><a href="https://docs.rs/sqlrite">Documentation (coming soon)</a></td>
-        <td><a href="https://docs.rs/sqlrite"><img src="https://docs.rs/sqlrite/badge.svg"></a></td>
+        <td><a href="https://docs.rs/sqlrite-engine">Rust API docs on docs.rs</a></td>
+        <td><a href="https://docs.rs/sqlrite-engine"><img src="https://docs.rs/sqlrite-engine/badge.svg"></a></td>
       </tr>
       <tr>
         <td><a href="https://discord.gg/dHPmw89zAE">Come and Chat about databases with us</a></td>
@@ -212,9 +212,9 @@ The project is staged in phases, each independently shippable. A finished phase
 **Phase 5 — Embedding surface: public API + language SDKs**
 - [x] **5a — Public Rust API** *(partial)*: `Connection` / `Statement` / `Rows` / `Row` / `OwnedRow` / `FromValue` / `Value` at the crate root; structured row return from the executor; `examples/rust/quickstart.rs` runnable via `cargo run --example quickstart`. Parameter binding + cursor abstraction deferred to 5a.2.
 - [x] **5b — C FFI shim**: new `sqlrite-ffi/` workspace crate ships `libsqlrite_c.{so,dylib,dll}` + a cbindgen-generated `sqlrite.h`. Opaque-pointer types, thread-local last-error, split `sqlrite_execute` (DDL/DML/transactions) vs `sqlrite_query`/`sqlrite_step` (SELECT iteration). Runnable `examples/c/hello.c` + `Makefile` (`cd examples/c && make run`).
-- [x] **5c — Python SDK**: new `sdk/python/` workspace crate via PyO3 (`abi3-py38`) + maturin. DB-API 2.0-inspired — `sqlrite.connect(path)` → `Cursor.execute` / `fetchall` / iteration, context-manager support (commit-on-clean-exit / rollback-on-exception), read-only connections, 16-test pytest suite. `examples/python/hello.py` runs after `maturin develop`. PyPI publish lands in Phase 6e.
-- [x] **5d — Node.js SDK**: new `sdk/nodejs/` workspace crate via napi-rs (N-API v9, Node 18+). Prebuilt `.node` binaries — no `node-gyp` install step. `better-sqlite3`-style sync API (`new Database(path)`, `stmt.all() / get() / iterate()` returning row objects), auto-generated TypeScript defs, 11 `node:test` integration tests. `examples/nodejs/hello.mjs` runs after `npm install && npm run build`. npm publish lands in Phase 6e.
-- [x] **5e — Go SDK**: new `sdk/go/` module at `github.com/joaoh82/rust_sqlite/sdk/go`; cgo-wired against `libsqlrite_c` from Phase 5b. Implements the full `database/sql/driver` surface so users get the standard-library experience (`sql.Open("sqlrite", path)`, `db.Query/Exec/Begin`, `rows.Scan(&id, &name)`). 9-test `go test` integration suite. `examples/go/hello.go` runs after `cargo build --release -p sqlrite-ffi`. Go modules publish via `sdk/go/v*` git tags in Phase 6e.
+- [x] **5c — Python SDK**: new `sdk/python/` workspace crate via PyO3 (`abi3-py38`) + maturin. DB-API 2.0-inspired — `sqlrite.connect(path)` → `Cursor.execute` / `fetchall` / iteration, context-manager support (commit-on-clean-exit / rollback-on-exception), read-only connections, 16-test pytest suite. `examples/python/hello.py` runs after `maturin develop`. PyPI publish landed in Phase 6f as `sqlrite`.
+- [x] **5d — Node.js SDK**: new `sdk/nodejs/` workspace crate via napi-rs (N-API v9, Node 18+). Prebuilt `.node` binaries — no `node-gyp` install step. `better-sqlite3`-style sync API (`new Database(path)`, `stmt.all() / get() / iterate()` returning row objects), auto-generated TypeScript defs, 11 `node:test` integration tests. `examples/nodejs/hello.mjs` runs after `npm install && npm run build`. npm publish landed in Phase 6g as `@joaoh82/sqlrite` (scoped — npm rejected the unscoped `sqlrite` name as too similar to `sqlite`).
+- [x] **5e — Go SDK**: new `sdk/go/` module at `github.com/joaoh82/rust_sqlite/sdk/go`; cgo-wired against `libsqlrite_c` from Phase 5b. Implements the full `database/sql/driver` surface so users get the standard-library experience (`sql.Open("sqlrite", path)`, `db.Query/Exec/Begin`, `rows.Scan(&id, &name)`). 9-test `go test` integration suite. `examples/go/hello.go` runs after `cargo build --release -p sqlrite-ffi`. Module publish landed in Phase 6i — `go get github.com/joaoh82/rust_sqlite/sdk/go@vX.Y.Z` resolves directly via VCS tag.
 - [ ] **5f — Rust crate polish** *(deferred — Phase 6c companion)*: crate metadata, docs.rs config, prep for `cargo publish`. Deferred to land alongside the actual publish workflow.
 - [x] **5g — WASM** build: new `sdk/wasm/` crate via `wasm-bindgen`; engine runs entirely in a browser tab. Feature-gated root crate (`cli` + `file-locks` optional, both default-on) so WASM disables fs2 / rustyline / clap / env_logger cleanly. `Database` class with `exec/query/columns/inTransaction`; rows as plain JS objects in projection order. ~1.8 MB wasm / ~500 KB gzipped. Three `wasm-pack` targets (web/bundler/nodejs). `examples/wasm/` ships a self-contained HTML SQL console.
 - [ ] Code examples for every language under `examples/{rust,python,nodejs,go,wasm}/`
@@ -226,11 +226,11 @@ Lockstep versioning — one dispatch bumps every product to the same `vX.Y.Z`. T
 - [x] **6b — CI**: `.github/workflows/ci.yml` runs on every PR + push to main. Seven parallel jobs: `rust-build-and-test` (Linux/macOS/Windows × cargo build + test), `rust-lint` (fmt + clippy + doc), `python-sdk` (Linux/macOS/Windows × maturin develop + pytest in a venv), `nodejs-sdk` (Linux/macOS/Windows × napi build + node --test), `go-sdk` (Linux/macOS × cargo build sqlrite-ffi + go test), `wasm-build` (wasm-pack + size report), `desktop-build` (npm ci + Tauri Rust compile). Cargo / npm / pip caching for fast PR turnaround.
 - [x] **6c — Trusted publisher setup + branch protection runbook**: [`docs/release-secrets.md`](docs/release-secrets.md) captures the one-time web-UI setup — crates.io token in the `release` environment, OIDC trusted publishers on PyPI (`sqlrite`) and npm (`@joaoh82/sqlrite` + `@joaoh82/sqlrite-wasm` — both scoped because npm's similarity check rejects the unscoped names against `sqlite`/`sqlite3`/`sqlite-wasm`), GitHub `release` environment with required reviewer, branch protection on `main` requiring 14 CI jobs + 1 review. No code changes — executable as-is, ready to run through in the GitHub + registry UIs.
 - [x] **6d — Release PR + skeleton publish**: two workflows under `.github/workflows/`. `release-pr.yml` (manual dispatch with version input → bump-version.sh → PR), `release.yml` (fires on `release: v<semver>` merge commit → `tag-all` + `publish-crate` + `publish-ffi` matrix [linux x86_64/aarch64, macOS aarch64, windows x86_64] + umbrella release). Idempotent tag creation so "Re-run failed jobs" works after partial failures. `cargo publish` gated by the `release` environment's required-reviewer rule. First canary: `v0.1.1`.
-- [ ] **6e — Desktop publish**: add `publish-desktop` to `release.yml` — Tauri build matrix → unsigned `.AppImage` / `.deb` / `.dmg` / `.msi` → GitHub Release
-- [ ] **6f — Python SDK publish**: `maturin-action` → abi3 wheels for manylinux x86_64/aarch64 + macOS universal + Windows x86_64 → PyPI via OIDC
-- [ ] **6g — Node.js SDK publish**: `@napi-rs/cli` → `.node` binaries per platform → npm via OIDC
+- [x] **6e — Desktop publish**: `publish-desktop` matrix in `release.yml` — `tauri-action@v0` on ubuntu-22.04 (AppImage + deb + rpm), macos-latest (dmg aarch64 + .app tarball), windows-latest (msi + NSIS exe). Seven installer formats per release. Unsigned for now (Phase 6.1 wires up signing). Pre-generated icons committed to `desktop/src-tauri/icons/` keep CI deterministic.
+- [x] **6f — Python SDK publish**: 3-job design (`build-python-wheels` matrix → `build-python-sdist` → `publish-python` aggregator). `maturin-action` builds abi3-py38 wheels for Linux x86_64/aarch64 (manylinux2014), macOS aarch64, Windows x86_64 + an sdist. Atomic OIDC upload via `pypa/gh-action-pypi-publish` to `sqlrite` on PyPI. PEP 740 publish attestations attached automatically.
+- [x] **6g — Node.js SDK publish**: 2-job design (`build-nodejs-binaries` matrix → `publish-nodejs` aggregator). `@napi-rs/cli` builds `.node` binaries per platform; `index.js` dispatcher selects the right one at require time. OIDC publish to npm as `@joaoh82/sqlrite` with sigstore-signed provenance. Painful three-iteration debug to land the OIDC dance — see [docs/release-secrets.md](docs/release-secrets.md) §3 for the playbook the next person should use.
 - [x] **6h — WASM publish**: `wasm-pack build --target bundler --scope joaoh82` + `npm publish --provenance` (OIDC) → `@joaoh82/sqlrite-wasm` on npm. Single job, no matrix (WebAssembly is universal). `.wasm` also attached to the `sqlrite-wasm-v<V>` GitHub Release.
-- [ ] **6i — Go SDK publish**: `sdk/go/vX.Y.Z` git tag + attach FFI tarballs to the Go GitHub Release for `go get` users who want prebuilt `libsqlrite_c`
+- [x] **6i — Go SDK publish**: no registry — `sdk/go/v<V>` git tag (Go modules pull straight from VCS), GitHub Release at that tag with the FFI tarballs from `publish-ffi` re-attached so Go users have one page with `go get` + cgo deps. `go get github.com/joaoh82/rust_sqlite/sdk/go@vX.Y.Z` resolves through proxy.golang.org as soon as the tag is pushed.
 
 **Phase 6.1 — Code signing** *(follow-up)*
 - [ ] macOS Apple Developer ID cert → `codesign` + `notarytool` in `tauri-action`

{sqlrite-0.1.8 → sqlrite-0.1.10}/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sqlrite-desktop-frontend",
   "private": true,
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "scripts": {
     "dev": "vite",

{sqlrite-0.1.8 → sqlrite-0.1.10}/docs/_index.md

@@ -34,8 +34,11 @@ As of April 2026, SQLRite has:
 
 - A working SQL engine (in-memory + on-disk with a real B-Tree per table + secondary indexes, Phases 0 – 3 complete)
 - WAL-backed persistence with crash-safe checkpointing, shared/exclusive lock modes, and real `BEGIN` / `COMMIT` / `ROLLBACK` transactions (Phase 4 complete)
-- A stable public Rust embedding API (Phase 5a complete — the current frontier is Phase 5b, the C FFI shim, and the language SDKs that build on it)
+- A stable public Rust embedding API plus C FFI shim and SDKs for Python, Node.js, Go, and WASM (Phase 5 complete except the optional 5f crate-polish task)
 - A Tauri 2.0 + Svelte desktop app (Phase 2.5 complete)
+- A fully-automated release pipeline that ships every product to its registry on every release with one human action — Rust crate to crates.io (`sqlrite-engine`), Python wheels to PyPI (`sqlrite`), Node.js + WASM to npm (`@joaoh82/sqlrite` + `@joaoh82/sqlrite-wasm`), Go module via `sdk/go/v*` git tag, plus C FFI tarballs and unsigned desktop installers as GitHub Release assets (Phase 6 complete)
+
+The active frontier is **Phase 7 — AI-era extensions**.
 
 See the [Roadmap](roadmap.md) for the full phase plan.
 
@@ -45,6 +48,11 @@ See the [Roadmap](roadmap.md) for the full phase plan.
 - [Release secrets runbook](release-secrets.md) — one-time web-UI setup for crates.io, PyPI, npm, GitHub `release` environment, and `main` branch protection
 - [`scripts/`](../scripts/) — runnable tooling used by release workflows + reproducible locally (start with `scripts/bump-version.sh`)
 
+## Future work
+
+- [Phase 7 plan](phase-7-plan.md) — AI-era extensions (vector column type + HNSW, JSON, NL→SQL `ask()` API across REPL/library/SDKs/desktop/MCP, MCP server). **Approved 2026-04-26**, implementation starts at sub-phase 7a.
+- Phase 8 — Full-text search (FTS5-style BM25) + hybrid retrieval, deferred from Phase 7 per the plan-doc's Q1.
+
 ## Conventions
 
 - Code lives under [`src/`](../src/); docs live here under [`docs/`](./).

{sqlrite-0.1.8 → sqlrite-0.1.10}/docs/embedding.md

@@ -138,7 +138,7 @@ with sqlrite.connect("foo.sqlrite") as conn:
         print(row)  # tuples
 ```
 
-The Python binding wraps the Rust `Connection` directly (not via the C FFI) — PyO3 marshals types cheaper than a C round-trip. Build via `cd sdk/python && maturin develop`; tests via `python -m pytest sdk/python/tests/`. PyPI publish lands in Phase 6e.
+The Python binding wraps the Rust `Connection` directly (not via the C FFI) — PyO3 marshals types cheaper than a C round-trip. Build via `cd sdk/python && maturin develop`; tests via `python -m pytest sdk/python/tests/`. Phase 6f publishes abi3-py38 wheels to PyPI on every release via OIDC trusted publishing.
 
 Full API tour: [`sdk/python/README.md`](../sdk/python/README.md); runnable walkthrough: [`examples/python/hello.py`](../examples/python/hello.py).
 
@@ -157,7 +157,7 @@ for (const row of db.prepare('SELECT id, name FROM users').all()) {
 db.close();
 ```
 
-Unlike the C SDK, the Node.js binding wraps the Rust `Connection` directly (via napi-rs, no C FFI hop). Prebuilt `.node` binaries shipped per platform in Phase 6e — no `node-gyp` install step. TypeScript definitions (`index.d.ts`) auto-generated from the Rust source.
+Unlike the C SDK, the Node.js binding wraps the Rust `Connection` directly (via napi-rs, no C FFI hop). Phase 6g publishes prebuilt `.node` binaries per platform under the `@joaoh82/sqlrite` scope on npm, with sigstore-signed provenance attestations via OIDC trusted publishing — no `node-gyp` install step on the user side. TypeScript definitions (`index.d.ts`) auto-generated from the Rust source.
 
 Full API tour: [`sdk/nodejs/README.md`](../sdk/nodejs/README.md); runnable walkthrough: [`examples/nodejs/hello.mjs`](../examples/nodejs/hello.mjs).
 

{sqlrite-0.1.8 → sqlrite-0.1.10}/docs/file-format.md

@@ -152,9 +152,12 @@ tag       u8
   0x01 Real         f64 little-endian, 8 bytes
   0x02 Text         varint length, UTF-8 bytes
   0x03 Bool         u8 (0 or 1)
+  0x04 Vector       varint dim, then dim × 4 bytes f32 little-endian   (Phase 7a, format v4)
 body      variable (see tag)
 ```
 
+The Vector tag (Phase 7a) carries its own dimension as a leading varint so `decode_value` doesn't need schema context to read it. For the typical embedding sizes (384, 768, 1536) the dim varint is 2-3 bytes; the f32 array dominates payload size (4·dim bytes). Vectors that exceed the local-cell budget spill into the overflow chain via the same machinery as long Text values — no Vector-specific overflow path.
+
 ### Overflow cell body
 
 When a cell's full local encoding would exceed `OVERFLOW_THRESHOLD` (1022 bytes in the current code), the body is written to a chain of `Overflow` pages instead, and the on-page cell is replaced by a compact marker:
@@ -280,7 +283,8 @@ These are not all enforced on open — we validate the header strictly and rely
 
 - **v1** (Phases 2 / 3a / 3b) — schema catalog and table data were opaque `bincode` blobs chained across typed payload pages.
 - **v2** (Phases 3c / 3d) — cell-based storage and `sqlrite_master`. Phase 3d added interior pages without a version bump.
-- **v3** (Phase 3e, current) — `sqlrite_master` gains a `type` column; secondary indexes persist as their own cell-based B-Trees whose leaves carry `KIND_INDEX` cells.
+- **v3** (Phase 3e) — `sqlrite_master` gains a `type` column; secondary indexes persist as their own cell-based B-Trees whose leaves carry `KIND_INDEX` cells.
+- **v4** (Phase 7a, current) — value block dispatch gains the `0x04 Vector` tag for the new `VECTOR(N)` column type. Per the [Phase 7 plan's Q8](phase-7-plan.md#q8-file-format-version-bump), later Phase 7 sub-phases (JSON storage, HNSW indexes) will add their own value/cell tags inside this same v4 envelope — no v5 mid-Phase-7. The `CREATE TABLE` SQL stored in `sqlrite_master` carries vector columns as `VECTOR(N)` in the type position; on open, the engine re-parses that SQL and reconstructs `DataType::Vector(N)` from the `Custom` AST node sqlparser produces.
 
 The page header (7 bytes) and chaining mechanism are stable across future phases. Phase 4's WAL introduces a sibling file (`.sqlrite-wal`) rather than changing the main file format.