@cipherstash/protect-ffi 0.25.0 → 0.27.0

package/README.md

@@ -44,6 +44,66 @@ $ node
 > console.log({ciphertext, plaintext});
 ```
 
+## EQL version selection
+
+`newClient` accepts an `eqlVersion` option selecting the wire format that
+`encrypt` / `encryptBulk` / `encryptQuery` emit:
+
+```js
+// EQL v2 (default) — the `eql_v2_encrypted` payload format
+const v2 = await addon.newClient({ encryptConfig })
+
+// EQL v3 — payloads for the per-capability `eql_v3` domains
+const v3 = await addon.newClient({ encryptConfig, eqlVersion: 3 })
+```
+
+With `eqlVersion: 3`, each column's payload targets the `eql_v3` domain
+derived from its `cast_as` and indexes:
+
+| `cast_as` | family | indexes | domain |
+|-----------|--------|---------|--------|
+| `text` | `text` | `unique` + `ore` + `match` | `text_search` |
+| `text` | `text` | `unique` + `ore` | `text_ord_ore` |
+| `text` | `text` | `match` | `text_match` |
+| `text` | `text` | `unique` | `text_eq` |
+| `int` / `small_int` / `bigint` | `integer` / `smallint` / `bigint` | `ore` (with or without `unique`) | `<family>_ord_ore` |
+| `int` / `small_int` / `bigint` | `integer` / `smallint` / `bigint` | `unique` | `<family>_eq` |
+| `number` / `decimal` / `date` / `timestamp` | `double` / `numeric` / `date` / `timestamp` | as above | as above |
+| any scalar | — | none | storage-only domain (`text`, `integer`, …) |
+| `boolean` | `boolean` | none only | `boolean` (storage-only — any index errors) |
+| `json` | `json` | `ste_vec` (required) | `json` |
+
+Notes:
+
+- The richest matching domain wins, and it must cover every configured
+  capability — a combination that would silently drop a term errors instead
+  (e.g. `unique` + `match`, `unique` + `ope` + `match`, or `ore` + `match`
+  on text: no single domain carries those term sets, so add the missing
+  index to reach `text_search`, split the capabilities across columns, or
+  use `eqlVersion: 2`).
+- Exception: dropping a *term* is fine when the *capability* survives.
+  Non-text ordering domains carry only `ob`, so `unique` + `ore` on a
+  numeric column drops `hm` — equality still works via the ORE operators.
+- Ordered text requires a `unique` index (`text_ord_ore`/`text_ord_ope`
+  carry `hm` + `ob`/`op`); `ore`-only text errors.
+- `decrypt` accepts **both** formats regardless of `eqlVersion`, so v2 and
+  v3 data can coexist during a migration.
+- v3 query encryption currently supports JSON containment only; scalar and
+  selector queries throw `EQL_V3_QUERY_UNSUPPORTED` and need an
+  `eqlVersion: 2` client.
+- `ope`-indexed columns map to `<family>_ord_ope` but cannot be produced
+  end-to-end yet: the client does not emit the `op` term (CIP-3280).
+
+> [!NOTE]
+> **Breaking TypeScript change:** `encrypt`/`encryptBulk` now return
+> `EncryptedPayload` (`Encrypted | EncryptedV3`) instead of `Encrypted`.
+> Runtime output is unchanged for v2 clients, but code that accessed `.k`
+> or assigned the result to `Encrypted` must narrow first. v3 scalars carry
+> no `k`, so guard its presence before reading it:
+> `'k' in payload && payload.k === 'ct'` (a v2 scalar), or check
+> `payload.v === 3` to detect the v3 members. (A bare `payload.k === 'ct'`
+> does not compile against the union.)
+
 ## Errors
 
 Async API calls throw `ProtectError` with a stable `code` for programmatic handling.

package/dist/wasm/protect_ffi_bg.js

@@ -570,7 +570,7 @@ export function __wbg_new_typed_aaaeaf29cf802876(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return wasm_bindgen__convert__closures_____invoke__h1201fec59d36da32(a, state0.b, arg0, arg1);
+                return wasm_bindgen__convert__closures_____invoke__h0cb80728b35f261e(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -742,13 +742,13 @@ export function __wbg_wasmclient_new(arg0) {
     return ret;
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 494, function: Function { arguments: [], shim_idx: 495, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h379cc5f9ba73967b, wasm_bindgen__convert__closures_____invoke__hc060a2339985e908);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 879, function: Function { arguments: [], shim_idx: 880, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hd9dedd770edb0aa1, wasm_bindgen__convert__closures_____invoke__h8b170b34f8b593df);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 542, function: Function { arguments: [Externref], shim_idx: 543, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h18e55ed08acd10aa, wasm_bindgen__convert__closures_____invoke__h425499e9ab8a95b4);
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 932, function: Function { arguments: [Externref], shim_idx: 933, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h94971d029da3e81d, wasm_bindgen__convert__closures_____invoke__hacad64c6c6b78997);
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0) {
@@ -785,19 +785,19 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
-function wasm_bindgen__convert__closures_____invoke__hc060a2339985e908(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hc060a2339985e908(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h8b170b34f8b593df(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h8b170b34f8b593df(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h425499e9ab8a95b4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h425499e9ab8a95b4(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__hacad64c6c6b78997(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__hacad64c6c6b78997(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h1201fec59d36da32(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h1201fec59d36da32(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h0cb80728b35f261e(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h0cb80728b35f261e(arg0, arg1, arg2, arg3);
 }
 
 

package/dist/wasm/protect_ffi_bg.wasm.d.ts

@@ -25,11 +25,11 @@ export const intounderlyingbytesource_cancel: (a: number) => void;
 export const intounderlyingbytesource_pull: (a: number, b: any) => any;
 export const intounderlyingbytesource_start: (a: number, b: any) => void;
 export const intounderlyingbytesource_type: (a: number) => number;
-export const wasm_bindgen__closure__destroy__h379cc5f9ba73967b: (a: number, b: number) => void;
-export const wasm_bindgen__closure__destroy__h18e55ed08acd10aa: (a: number, b: number) => void;
-export const wasm_bindgen__convert__closures_____invoke__h425499e9ab8a95b4: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h1201fec59d36da32: (a: number, b: number, c: any, d: any) => void;
-export const wasm_bindgen__convert__closures_____invoke__hc060a2339985e908: (a: number, b: number) => void;
+export const wasm_bindgen__closure__destroy__hd9dedd770edb0aa1: (a: number, b: number) => void;
+export const wasm_bindgen__closure__destroy__h94971d029da3e81d: (a: number, b: number) => void;
+export const wasm_bindgen__convert__closures_____invoke__hacad64c6c6b78997: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h0cb80728b35f261e: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h8b170b34f8b593df: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;