feat(stack,cli): EQL v3 typed schema, typed client, Supabase/Drizzle integrations on eql-3.0.0 + protect-ffi 0.29

.changeset/cli-eql-v3-single-bundle.md

@@ -0,0 +1,16 @@
+---
+'stash': minor
+---
+
+`stash eql install --eql-version 3` now installs the eql-3.0.0 GA bundle,
+vendored from the pinned `@cipherstash/eql` package (sha256-verified).
+
+Since eql-3.0.0 one artifact installs everywhere: the operator-class
+statements self-skip when the role lacks superuser (managed Postgres,
+Supabase) and the bundle disables the ORE-backed encrypted domains it cannot
+support. The separate v3 Supabase bundle variant is gone — `--supabase` and
+`--exclude-operator-family` no longer select a different v3 file (the role
+GRANTs for `eql_v3` / `eql_v3_internal` still apply with `--supabase`).
+
+The bundled skills are also refreshed for the eql-3.0.0 naming convention
+(`public.eql_v3_<name>` column domains) and the EQL v3 typed-schema surface.

.changeset/eql-v3-bigint-domains.md

@@ -0,0 +1,11 @@
+---
+'@cipherstash/stack': minor
+---
+
+Add the EQL v3 bigint domain family to the public DSL: `types.Bigint`,
+`types.BigintEq`, `types.BigintOrdOre`, and `types.BigintOrd`, backed by the
+`public.bigint*` concrete domains. Plaintext is a JS `bigint`, round-tripped
+losslessly across the protect-ffi 0.28 boundary (i64 bounds enforced at the
+FFI — out-of-range values surface as encryption errors). Index emission follows
+the numeric rule: `bigint_eq` → unique (hm); `bigint_ord`/`bigint_ord_ore` →
+ore (equality answered via ob).

.changeset/eql-v3-bundle-from-package.md

@@ -0,0 +1,9 @@
+---
+'@cipherstash/stack': patch
+---
+
+Source the EQL v3 install bundle from `@cipherstash/eql@3.0.0-alpha.3` instead of a hand-vendored 43k-line SQL fixture committed to the test tree. The package publishes its SQL and its TypeScript wire types from the same `eql-bindings` commit, so the bundle is now pinned to a released EQL version rather than tracked by convention.
+
+Test-and-tooling only — `@cipherstash/eql` is a `devDependency` and no public API changes.
+
+The staleness check in the v3 install helper now compares `eql_v3.version()` against the pinned release instead of probing for a hand-picked sentinel domain. The previous sentinel (`public.timestamp`) exists in both the old and new bundles, so it would have reported a stale install as current and left the suite silently running the wrong SQL.

.changeset/eql-v3-cli-install.md

@@ -0,0 +1,13 @@
+---
+"stash": minor
+---
+
+Add an EQL v3 install path to `stash eql install` via a new `--eql-version <2|3>`
+flag (default `2`). v3 installs the native concrete-domain schema (`public.*`
+type domains, `eql_v3` operators, `eql_v3_internal` constructors) from bundles
+vendored into `packages/cli/src/sql` by `scripts/build-eql-v3-sql.mjs` (full
+bundle + a Supabase variant with the two superuser-only operator-class chunks
+stripped). v3 currently supports the direct install path only —
+`--drizzle`/`--migration`/`--migrations-dir`/`--latest` are rejected — and the
+installer keys `isInstalled`/version checks and Supabase grants to the `eql_v3`
+schema.

.changeset/eql-v3-drizzle-fail-open-guards.md

@@ -0,0 +1,38 @@
+---
+'@cipherstash/stack': minor
+---
+
+Close two fail-open paths in the EQL v3 Drizzle adapter.
+
+`ops.contains()` now throws `EncryptionOperatorError` for a search term that
+tokenizes to nothing: the empty string, or a term shorter than the match index
+tokenizer's `token_length` (3 by default). Such a term produces an empty bloom
+filter, and `stored_bf @> '{}'` is true for every row — so a user searching
+`"ad"` silently received the entire table. Measured live, the terms `"ad"`,
+`"a"` and `"x"` each returned every seeded row, including one in which `"x"`
+did not appear.
+
+The floor counts Unicode codepoints, matching the tokenizer. A UTF-16 length
+check would wave through an astral-plane term — `"👍👍"` is 4 code units but
+only 2 codepoints, yields no trigram, and matched every row.
+
+**Breaking for callers passing short terms:** `contains()` calls that previously
+returned every row now throw. Terms of 3+ codepoints are unaffected.
+
+`v3FromDriver()` now throws the new `EqlV3CodecError` on a payload that is not
+an EQL envelope, instead of surfacing a raw `SyntaxError` for malformed JSON and
+passing a bare scalar through unchecked — `v3FromDriver('5')` previously returned
+`5` typed as `Encrypted`, which then reached `decrypt` as garbage. The guard
+accepts both scalar envelopes (ciphertext at `c`) and SteVec documents
+(ciphertext at `sv[0].c`). A SteVec's `sv` must be a non-empty array: `sv[0]` is
+the decryption root, so `sv: []` carries a ciphertext key but no ciphertext, and
+is now rejected rather than passed to `decrypt`. `EqlV3CodecError` is exported
+from `@cipherstash/stack/eql/v3/drizzle` so callers can catch it.
+
+Also removes an unreachable branch in `inArray`/`notInArray`, whose empty-list
+guard already throws before it.
+
+Note: the v2 Drizzle adapter's `like`/`ilike` path builds the same bloom filters
+and has the same short-term fail-open. It is **not** fixed here — v2 terms carry
+SQL wildcards, so the floor must be measured against what its tokenizer actually
+receives before the shared guard can be reused. Tracked separately.

.changeset/eql-v3-drizzle.md

@@ -0,0 +1,17 @@
+---
+"@cipherstash/stack": minor
+---
+
+Add EQL v3 Drizzle support at `@cipherstash/stack/eql/v3/drizzle`. A Drizzle-native
+`types` namespace (same PascalCase names as `@cipherstash/stack/eql/v3`) declares
+encrypted columns whose Postgres type is the semantic `public.<domain>`; the concrete
+type drives the legal query operators. `createEncryptionOperatorsV3` provides
+capability-checked `eq`/`ne`/`gt`/`gte`/`lt`/`lte`/`between`/`contains`/`inArray`/
+`asc`/`desc`/`and`/`or` that emit the latest two-argument `eql_v3` SQL functions with
+full-envelope operands, and
+`extractEncryptionSchemaV3` rebuilds the schema for `EncryptionV3`. The existing v2
+`@cipherstash/stack/drizzle` integration is unchanged.
+
+The v3 text-search helper is `contains`; obsolete `like`/`ilike` helpers are not
+exposed because v3 free-text search is token containment rather than SQL wildcard
+matching.

.changeset/eql-v3-ffi-0-28-concrete-types.md

@@ -0,0 +1,5 @@
+---
+'@cipherstash/stack': minor
+---
+
+Upgrade `@cipherstash/protect-ffi` to 0.28.0 and update EQL v3 concrete Postgres domain names to match the SQL fixture (`integer*`, `smallint*`, `bool`, `real*`, and `double*`). The public factories remain semantic (`Integer`, `Smallint`, `Boolean`, `Real`, `Double`) while their concrete domains change, so this is a minor release.

.changeset/eql-v3-ga-rebaseline.md

@@ -0,0 +1,23 @@
+---
+'@cipherstash/stack': minor
+---
+
+Re-baseline EQL v3 on the eql-3.0.0 GA release and protect-ffi 0.29.
+
+- **Breaking (v3 preview surface):** the EQL v3 column domains follow the
+  eql-3.0.0 naming convention — flat, prefixed names in `public`
+  (`public.eql_v3_text_search`, `public.eql_v3_integer_ord`, …) instead of the
+  alpha-era bare names. Databases installed from an alpha bundle must be
+  re-installed (`stash eql install --eql-version 3` replaces the schema).
+- `encryptQuery` under `eqlVersion: 3` now returns EQL v3 query operands
+  (protect-ffi 0.29): term-only scalar operands for the `eql_v3.query_<name>`
+  domains, the `eql_v3.query_jsonb` containment needle, and bare selector
+  hashes for JSON path queries — v3 scalar and selector queries no longer
+  throw `EQL_V3_QUERY_UNSUPPORTED` (the code is gone).
+- v2 `searchableJson()` columns now pin the SteVec encoding to `standard`
+  explicitly. protect-ffi 0.29 flipped the library default to `compat`
+  (EQL v3's encoding); without the pin, v2 JSON containment queries would
+  silently match nothing and newly written rows would not be comparable with
+  existing ones.
+- The EQL v3 test/install SQL is sourced from the pinned `@cipherstash/eql`
+  package (3.0.0) instead of a hand-vendored fixture.

.changeset/eql-v3-public-domains.md

@@ -0,0 +1,5 @@
+---
+'@cipherstash/stack': patch
+---
+
+Re-vendor the EQL v3 SQL bundle and align the v3 DSL to it: encrypted type domains now live in the `public` schema (`public.text`, `public.integer`, …) rather than `eql_v3`, and the boolean domain is `public.boolean` (was `eql_v3.bool`). The `eql_v3` schema now holds only the operator-backing functions, and the index-term constructors (`hmac_256`, `ore_block_256`, `bloom_filter`) moved to `eql_v3_internal`. This keeps the SDK's emitted domain names byte-matched to the installed bundle so `CREATE TABLE`/cast resolution succeeds.

.changeset/eql-v3-supabase-adapter.md

@@ -0,0 +1,65 @@
+---
+'@cipherstash/stack': minor
+---
+
+Add `encryptedSupabaseV3` — the EQL v3 dialect of the Supabase adapter. It is
+now a connect-time-async factory: `await encryptedSupabaseV3(url, key)` (or
+`(client)`) introspects the database over `DATABASE_URL`, detects EQL v3 columns
+by their Postgres domain (`information_schema.columns.domain_name`), and derives
+each column's encryption config from its domain — callers no longer pass a
+schema to `from()`. `select('*')` is supported (expanded from the introspected
+column list, and aliased back to each declared column's JS property name so a
+property→DB rename round-trips). A column using an EQL v3 domain this SDK version does not model
+(e.g. `public.json`, `*_ord_ope`) throws at construction rather than silently
+passing through. Supplying `schemas` remains optional and adds compile-time
+types plus startup verification of the declared tables against the database.
+Requires a Postgres connection for introspection (`pg` is a new optional peer),
+so it cannot run in a Worker or the browser.
+
+Every column name a query carries — filters, `match`, `not`, raw `filter`,
+`or()`, `order()`, and the `onConflict` option — is now resolved from its JS
+property name to its DB column name in a single pass before the query is built,
+so a declared rename round-trips everywhere rather than only on the paths that
+remembered to translate.
+
+`order()` on ANY encrypted v3 column is now rejected — at compile time when
+`schemas` is supplied, and at runtime otherwise. The EQL v3 domains are
+`DOMAIN … AS jsonb` and the bundle declares no btree operator class on them, so
+`ORDER BY col` resolves through jsonb's default `jsonb_cmp` and sorts by the
+envelope's byte structure: a stable, plausible-looking, meaningless row order,
+with no error. Correct ordering is `ORDER BY eql_v3.ord_term(col)`, which
+PostgREST's `order=` cannot express. Order by a plaintext column, expose
+`eql_v3.ord_term()` as a generated column or view, or use the EQL v3 Drizzle
+integration, which emits `ord_term` directly. Note `gte`/`lte` filters remain
+correct: the comparison operators *are* declared on the ord domains, and only
+sorting resolves through the missing operator class.
+
+`.or()` now understands PostgREST's `column.not.<op>.<value>` negation. It was
+previously parsed as `{ op: 'not', value: '<op>.<value>' }`, so on an encrypted
+column `or('nickname.not.in.(ada,grace)')` encrypted the literal string
+`in.(ada,grace)` as a single plaintext and produced a filter that silently
+matched nothing.
+
+Free-text search on the v3 builder is `contains(column, value)`. `like`/`ilike`
+are not exposed, because EQL v3 free-text search is token containment over a
+bloom filter (`@>`, backed by `eql_v3.contains`) rather than SQL wildcard
+matching — `%` is tokenized like any other character, so a `like` pattern is a
+category error. This matches the v3 Drizzle integration, which omits them for
+the same reason. On an encrypted column `like`/`ilike` now throw and name
+`contains`; on a plaintext column they remain ordinary PostgREST filters.
+
+`contains` is narrowed at compile time to columns whose domain carries the
+`freeTextSearch` capability (`public.text_match`, `public.text_search`), and
+guarded at runtime for the untyped surface. A raw `filter(column, operator, …)`
+on an encrypted v3 column now derives its query type from the operator instead
+of always encrypting an equality term, so `filter('bio', 'cs', …)` on a
+`public.text_match` column works rather than being rejected, and an unsupported
+operator throws instead of silently encrypting the wrong term.
+
+Substring `contains` still matches only when the needle equals the stored value
+or is exactly the tokenizer's window (3 characters): the operand is a storage
+envelope whose bloom carries the whole needle as an `include_original` token.
+This is shared with v3 Drizzle's `contains` and tracked upstream in EQL.
+
+v2 (`encryptedSupabase`) is unchanged: it keeps `like`/`ilike` (`eql_v2.like`,
+`~~`) and its raw-`filter` query-type mapping, so no v2 ciphertext moves.

.changeset/eql-v3-text-search.md

@@ -0,0 +1,18 @@
+---
+"@cipherstash/stack": minor
+---
+
+Add the EQL v3 `text_search` authoring DSL on a new `@cipherstash/stack/eql/v3`
+subpath (`types.TextSearch`, v3 `encryptedTable` / `buildEncryptConfig`). The v3
+builders emit the existing `EncryptConfig` shape, so encryption, payloads, and
+query paths are unchanged at runtime.
+
+Also widens the public client types (`EncryptionClientConfig.schemas`,
+`EncryptOptions`, `SearchTerm`/`EncryptQueryOptions`) to a structural contract so
+both v2 and v3 builders are accepted by `Encryption` / `encrypt` / `decrypt` /
+`encryptQuery`. This is a backward-compatible widening — existing v2 usage is
+unaffected. The structural contracts themselves (`BuildableColumn`,
+`BuildableQueryColumn`, `BuildableV3QueryableColumn`, `BuildableTable`,
+`BuildableTableColumns`) and the `encryptModel` return-type mapper
+(`EncryptedFromBuildableTable`) are exported from `@cipherstash/stack/types` so
+consumers can name them.

.changeset/eql-v3-typed-client.md

@@ -0,0 +1,29 @@
+---
+"@cipherstash/stack": minor
+---
+
+Add a strongly-typed EQL v3 client surface on a new `@cipherstash/stack/v3`
+subpath (`EncryptionV3`, `typedClient`, `TypedEncryptionClient`). It re-exports
+the v3 `types` namespace and table API (from `@cipherstash/stack/eql/v3`), so a
+single import provides everything needed to author and use a v3 schema.
+
+Every method derives its types from the concrete `table` / `column` builder
+arguments:
+
+- `encrypt` / `encryptQuery` pin the plaintext to the column's domain type
+  (`text → string`, `timestamp → Date`, …).
+- `encryptQuery` constrains `queryType` to the column's capabilities and rejects
+  storage-only columns at compile time.
+- `encryptModel` / `bulkEncryptModels` validate schema-column fields against their
+  inferred plaintext type (passthrough fields are untouched) and return a precise
+  encrypted model.
+- `decryptModel` / `bulkDecryptModels` return the precise plaintext model,
+  reconstructing `Date` values from the encrypt-config `cast_as`.
+
+Because the typed methods bind to the concrete branded v3 classes, a hand-rolled
+structural table/column is rejected — closing the soundness gap where a non-branded
+table could be encrypted at runtime while typed as plaintext.
+
+Runtime behaviour is unchanged: the encrypt/query paths return the same operations
+as the base client; only the model-decrypt paths add a per-column `Date`
+reconstruction step. The v2 client surface (`Encryption`) is untouched.

.changeset/eql-v3-typed-schema.md

@@ -0,0 +1,7 @@
+---
+'@cipherstash/stack': minor
+---
+
+Add EQL v3 schema builders for supported generated SQL domains under `@cipherstash/stack/eql/v3`, exposed as the `types` namespace (one member per supported EQL v3 domain, e.g. `types.TextEq` / `types.IntegerOrd` / `types.Timestamp`), including explicit query capability metadata (`getQueryCapabilities()` / `isQueryable()`) and v3 table support in model encryption helpers (`encryptModel` / `bulkEncryptModels`).
+
+Also widen the accepted plaintext input type for `encrypt` / `encryptQuery` to include `Date` (via the new `Plaintext` type), so v3 `date` / `timestamp` domains can be encrypted and queried with their natural JavaScript values.

.changeset/rename-db-install-to-eql-install.md

@@ -0,0 +1,11 @@
+---
+"stash": minor
+"@cipherstash/wizard": minor
+---
+
+Rename `stash db install` to `stash eql install`. The command scaffolds
+`stash.config.ts` and installs the EQL extensions, so it now lives under a
+dedicated `eql` command group. `stash db install` keeps working as a
+deprecated alias that prints a warning pointing at the new name. All help
+text, hints, generated migration headers, and wizard steps now reference
+`stash eql install`.

.changeset/schema-stevec-standard-pin.md

@@ -0,0 +1,8 @@
+---
+'@cipherstash/schema': patch
+---
+
+`searchableJson()` now pins the SteVec encoding mode to `standard` explicitly.
+protect-ffi 0.29 flipped the library default to `compat` (the EQL v3
+encoding); pinning keeps the v2 wire format byte-stable so existing encrypted
+JSON columns stay queryable and comparable.