boundlessdb 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,135 @@
 
 All notable changes to BoundlessDB will be documented in this file.
 
+## [0.9.0] - 2026-03-01
+
+### Breaking Changes
+
+#### Renamed: `withKey()` → `andKey()`
+
+The chaining method for AND key constraints has been renamed to make the semantics immediately clear:
+
+```typescript
+// Before (v0.8.0)
+store.query()
+  .matchType('StudentSubscribed')
+  .withKey('course', 'cs101')
+  .withKey('student', 'alice')
+  .read();
+
+// After (v0.9.0)
+store.query()
+  .matchType('StudentSubscribed')
+  .andKey('course', 'cs101')
+  .andKey('student', 'alice')
+  .read();
+```
+
+**Migration:** Find and replace `.withKey(` → `.andKey(` in your codebase.
+
+### Added
+
+#### Key-Only Queries: `matchKey(key, value)`
+
+Query events by key without specifying event types. This is the DCB-native way to query — by tags, not by event type.
+
+```typescript
+// "Everything about course cs101" — no need to list event types!
+const result = await store.query()
+  .matchKey('course', 'cs101')
+  .read();
+
+// AND: "Alice's enrollment in cs101"
+const result = await store.query()
+  .matchKey('course', 'cs101')
+  .andKey('student', 'alice')
+  .read();
+```
+
+**Why this matters:** Previously, querying by key required listing every event type manually:
+
+```typescript
+// Before: 8 event types just to query a cart 😱
+const cartEventTypes = [
+  'CartCreated', 'ItemAdded', 'ItemRemoved', 'ItemArchived',
+  'CartSubmitted', 'CartCleared', 'CartPublished', 'CartPublicationFailed',
+];
+const result = await store.read({
+  conditions: cartEventTypes.map(type => ({ type, key: 'cart', value: cartId })),
+});
+
+// After: one line ✨
+const result = await store.query()
+  .matchKey('cart', cartId)
+  .read();
+```
+
+Key-only queries work with `andKey()` for AND logic, `fromPosition()`, `limit()`, and `appendCondition`.
+
+#### Multi-Type Queries: `matchType(...types)`
+
+`matchType()` now accepts multiple types (variadic). Types within one call are OR:
+
+```typescript
+// "All course lifecycle events for cs101"
+const result = await store.query()
+  .matchType('CourseCreated', 'CourseCancelled')
+  .andKey('course', 'cs101')
+  .read();
+```
+
+This maps directly to the DCB spec's QueryItem, where a single item can have multiple types.
+
+### Query API Summary
+
+| Method | Role |
+|---|---|
+| `matchKey(key, value)` | Start condition by key (any event type). |
+| `matchType(...types)` | Start condition by type(s). |
+| `andKey(key, value)` | Add AND key constraint to last condition. |
+| `matchTypeAndKey(type, key, value)` | Shorthand for `matchType(type).andKey(key, value)`. |
+
+**Rules:**
+- `matchType()` / `matchKey()` → starts a new condition (OR between conditions)
+- `andKey()` → extends the last condition (AND within condition)
+
+### DCB Spec Mapping
+
+| DCB Spec | BoundlessDB |
+|---|---|
+| QueryItem.types (OR within) | `matchType('A', 'B')` |
+| QueryItem.tags (AND within) | `.andKey('key', 'value')` chain |
+| Tag-only QueryItem | `matchKey('key', 'value')` |
+| Multiple QueryItems (OR) | Multiple `matchType()` / `matchKey()` calls |
+
+### Tests
+
+- **214 tests** (up from 174): +40 new tests covering key-only queries, multi-type queries, AND/OR combinations, appendCondition propagation, and error cases.
+
+### Documentation
+
+- README updated with new API examples throughout
+- `docs/sqlite-queries.md`: New sections for key-only, key-only AND, multi-type queries. Decision logic expanded to all 8 condition variants.
+- Landing page: Updated highlight section and code examples
+- Issue #83: Full API documentation with all query patterns
+
+---
+
+## [0.8.0] - 2026-02-28
+
+### Added
+
+- **Exponential backoff with jitter** for PostgreSQL serialization retries. Default: 10 retries, 50ms base delay, full jitter. Configurable via `PostgresRetryOptions`.
+  ```typescript
+  new PostgresStorage(url, { maxRetries: 10, retryBaseMs: 50, retryJitter: true });
+  ```
+- **`--conflicts` flag** for benchmark scripts. Tests conflict detection overhead and concurrent writers (10 parallel writers, same/different keys).
+- **Aggressive conflict benchmarks**: 50 iterations × 10 writers × 5 events per writer (~5,500 events per run).
+
+### Fixed
+
+- **PostgreSQL concurrent writers no longer crash** under high contention. Previously 3 retries without backoff caused failures with 10+ parallel writers.
+
 ## [0.7.0] - 2026-02-28
 
 ### Added

package/README.md

@@ -84,26 +84,21 @@ event_keys: [pos:1, course, cs101], [pos:1, student, alice]
 ```
 
 ### 4️⃣ Query by Keys
-Find all events matching any combination of key conditions:
+Find all events matching key conditions — no need to list event types:
 ```typescript
-const result = await store.read({
-  conditions: [
-    { type: 'StudentSubscribed', key: 'course', value: 'cs101' }
-  ]
-});
+const result = await store.query()
+  .matchKey('course', 'cs101')
+  .read();
 // result.appendCondition captures: "I read all matching events up to position X"
 ```
 
 ## The DCB Pattern: Read → Decide → Write
 
 ```typescript
-// 1️⃣ READ — Query events and get an appendCondition
-const { events, appendCondition } = await store.read({
-  conditions: [
-    { type: 'CourseCreated', key: 'course', value: 'cs101' },
-    { type: 'StudentSubscribed', key: 'course', value: 'cs101' },
-  ]
-});
+// 1️⃣ READ — Query by key and get an appendCondition
+const { events, appendCondition } = await store.query<CourseEvent>()
+  .matchKey('course', 'cs101')
+  .read();
 
 // 2️⃣ DECIDE — Build state, run business logic
 const state = events.reduce(evolve, initialState);
@@ -154,12 +149,29 @@ if (result.conflict) {
 Build queries with a chainable API:
 
 ```typescript
+// Key-only: everything about course cs101 (any event type!)
 const { events, appendCondition } = await store.query<CourseEvent>()
-  .matchType('CourseCreated')                              // all events of type
-  .matchTypeAndKey('StudentSubscribed', 'course', 'cs101') // type + key = value
-  .withKey('student', 'alice')                             // AND: also match student key
-  .fromPosition(100n)                                      // start from position
-  .limit(50)                                               // limit results
+  .matchKey('course', 'cs101')
+  .read();
+
+// Multi-key AND: Alice's enrollment in cs101
+const enrollment = await store.query<CourseEvent>()
+  .matchKey('course', 'cs101')
+  .andKey('student', 'alice')
+  .read();
+
+// Multi-type: course lifecycle events for cs101
+const lifecycle = await store.query<CourseEvent>()
+  .matchType('CourseCreated', 'CourseCancelled')
+  .andKey('course', 'cs101')
+  .read();
+
+// Type + key
+const enrollments = await store.query<CourseEvent>()
+  .matchType('StudentSubscribed')
+  .andKey('course', 'cs101')
+  .fromPosition(100n)
+  .limit(50)
   .read();
 ```
 
@@ -167,14 +179,17 @@ const { events, appendCondition } = await store.query<CourseEvent>()
 
 | Method | Description |
 |--------|-------------|
-| `matchType(type)` | Match all events of type (unconstrained) |
-| `matchTypeAndKey(type, key, value)` | Match events of type where key=value |
-| `withKey(key, value)` | Add AND key to last condition (multi-key) |
+| `matchKey(key, value)` | Match events by key, regardless of type. Starts new condition (OR). |
+| `matchType(...types)` | Match events of one or more types. Starts new condition (OR). |
+| `matchTypeAndKey(type, key, value)` | Shorthand for `matchType(type).andKey(key, value)` |
+| `andKey(key, value)` | Add AND key constraint to last condition |
 | `fromPosition(bigint)` | Start reading from position |
 | `limit(number)` | Limit number of results |
 | `read()` | Execute query, returns `QueryResult` |
 
-The fluent API is equivalent to calling `store.read()` with conditions — use whichever style you prefer.
+**Rules:**
+- `matchType()` / `matchKey()` start a **new** condition (OR between conditions)
+- `andKey()` **extends** the last condition (AND within condition)
 
 ## AppendCondition
 
@@ -191,7 +206,7 @@ interface AppendCondition {
 
 ```typescript
 const result = await store.query()
-  .matchTypeAndKey('StudentSubscribed', 'course', 'cs101')
+  .matchKey('course', 'cs101')
   .read();
 
 // appendCondition = { failIfEventsMatch: [...], after: <last_position> }
@@ -251,51 +266,47 @@ await store.append(newEvents, null);
 Traditional streams give you ONE boundary. DCB lets you query ANY combination:
 
 ```typescript
-// "Has Alice already enrolled in CS101?"
-// Multi-key AND: must match BOTH keys on the SAME event
-const result = await store.query()
-  .matchType('StudentSubscribed')
-  .withKey('course', 'cs101')
-  .withKey('student', 'alice')
-  .read();
+// Key-only: "Everything about course cs101"
+store.query().matchKey('course', 'cs101').read()
+
+// Multi-key AND: "Alice's enrollment in cs101"
+store.query()
+  .matchKey('course', 'cs101')
+  .andKey('student', 'alice')
+  .read()
+
+// Multi-type + key: "Course lifecycle events for cs101"
+store.query()
+  .matchType('CourseCreated', 'CourseCancelled')
+  .andKey('course', 'cs101')
+  .read()
+
+// OR: "All cancellations OR everything about Alice"
+store.query()
+  .matchType('CourseCancelled')          // condition 1
+  .matchKey('student', 'alice')          // condition 2 (OR)
+  .read()
 ```
 
 ### AND vs OR
 
-- **`.withKey().withKey()`** = **AND** — the same event must have ALL specified keys
-- **Two separate conditions** = **OR** — events matching EITHER condition
+- **`.andKey()`** = **AND** — extends the last condition (same event must match all keys)
+- **`.matchType()` / `.matchKey()`** = **OR** — starts a new condition (events matching either)
 
 ```typescript
 // AND: Events where course='cs101' AND student='alice' (same event)
 store.query()
-  .matchType('StudentSubscribed')
-  .withKey('course', 'cs101')
-  .withKey('student', 'alice')
+  .matchKey('course', 'cs101')
+  .andKey('student', 'alice')
   .read();
 
 // OR: Events where course='cs101' OR student='alice' (different events)
 store.query()
-  .matchTypeAndKey('StudentSubscribed', 'course', 'cs101')
-  .matchTypeAndKey('StudentSubscribed', 'student', 'alice')
+  .matchKey('course', 'cs101')
+  .matchKey('student', 'alice')
   .read();
 ```
 
-Multi-key conditions also work in the object syntax:
-
-```typescript
-const result = await store.read({
-  conditions: [
-    {
-      type: 'StudentSubscribed',
-      keys: [
-        { name: 'course', value: 'cs101' },
-        { name: 'student', value: 'alice' }
-      ]
-    }
-  ]
-});
-```
-
 ## Config-based Key Extraction
 
 Keys are extracted from event payloads via configuration — events stay pure:
@@ -354,9 +365,10 @@ const consistency = {
 // Extracted keys: order="ORD-123", month="2026-02"
 
 // Query all orders from February 2026:
-const { events } = await store.read({
-  conditions: [{ type: 'OrderPlaced', key: 'month', value: '2026-02' }]
-});
+const { events } = await store.query()
+  .matchType('OrderPlaced')
+  .andKey('month', '2026-02')
+  .read();
 ```
 
 This is great for **Close the Books** patterns — query all events in a time period efficiently!
@@ -542,9 +554,9 @@ type ProductItemRemoved = Event<'ProductItemRemoved', {
 type CartEvents = ProductItemAdded | ProductItemRemoved;
 
 // Read with type safety
-const result = await store.read<CartEvents>({
-  conditions: [{ type: 'ProductItemAdded', key: 'cart', value: 'cart-123' }]
-});
+const result = await store.query<CartEvents>()
+  .matchKey('cart', 'cart-123')
+  .read();
 
 // TypeScript knows the event types!
 for (const event of result.events) {
@@ -556,90 +568,36 @@ for (const event of result.events) {
 
 ## Query Conditions
 
-Query conditions support both **constrained** (with key/value) and **unconstrained** (type-only) queries.
-
-### Constrained Query
-Match events of a type where a specific key has a specific value:
-
-```typescript
-// Get ProductItemAdded events where cart='cart-123'
-const result = await store.read({
-  conditions: [
-    { type: 'ProductItemAdded', key: 'cart', value: 'cart-123' }
-  ]
-});
-```
-
-### Unconstrained Query
-Omit `key` and `value` to match **all events of a type**:
-
-```typescript
-// Get ALL ProductItemAdded events (regardless of cart)
-const result = await store.read({
-  conditions: [
-    { type: 'ProductItemAdded' }  // no key/value = match all
-  ]
-});
-```
-
-### Mixed Conditions
-Combine constrained and unconstrained in one query (OR logic):
-
-```typescript
-// "Give me the course definition + all enrollments for cs101"
-const result = await store.read({
-  conditions: [
-    { type: 'CourseCreated', key: 'course', value: 'cs101' },
-    { type: 'StudentSubscribed', key: 'course', value: 'cs101' },
-    { type: 'StudentUnsubscribed', key: 'course', value: 'cs101' },
-  ]
-});
-
-// "All courses + only Alice's enrollments"
-const result = await store.read({
-  conditions: [
-    { type: 'CourseCreated' },                                  // unconstrained: ALL courses
-    { type: 'StudentSubscribed', key: 'student', value: 'alice' } // constrained: only Alice
-  ]
-});
-```
-
-### Same Type, Multiple Values
-Query multiple values of the same key:
+The fluent query builder is the recommended API. For advanced use, conditions can also be passed directly to `store.read()`:
 
 ```typescript
-// Get ProductItemAdded for cart-1 OR cart-2
-const result = await store.read({
-  conditions: [
-    { type: 'ProductItemAdded', key: 'cart', value: 'cart-1' },
-    { type: 'ProductItemAdded', key: 'cart', value: 'cart-2' }
-  ]
-});
-```
+// Key-only: events with key, regardless of type
+{ keys: [{ name: 'course', value: 'cs101' }] }
 
-### Type Safety
-With TypeScript, conditions are type-safe — three forms:
+// Type-only: all events of type
+{ type: 'CourseCreated' }
 
-```typescript
-// ✅ Unconstrained (type only)
-{ type: 'ProductItemAdded' }
-
-// ✅ Single key
+// Type + single key
 { type: 'ProductItemAdded', key: 'cart', value: 'cart-123' }
 
-// ✅ Multi-key AND
+// Type + multi-key AND
 { type: 'StudentSubscribed', keys: [
   { name: 'course', value: 'cs101' },
   { name: 'student', value: 'alice' }
 ]}
+
+// Multi-type
+{ types: ['CourseCreated', 'CourseCancelled'] }
+
+// Multi-type + keys
+{ types: ['CourseCreated', 'CourseCancelled'], keys: [{ name: 'course', value: 'cs101' }] }
 ```
 
-### Empty Conditions
-Empty conditions returns **all events** in the store:
+### All Events
 
 ```typescript
 // Get ALL events (useful for admin/debug/export)
-const result = await store.read({ conditions: [] });
+const result = await store.all().read();
 ```
 
 ## API Reference
@@ -659,9 +617,12 @@ Fluent query builder:
 
 ```typescript
 const result = await store.query<CourseEvent>()
-  .matchType('CourseCreated')                              // unconstrained (type only)
-  .matchTypeAndKey('StudentSubscribed', 'course', 'cs101') // type + single key
-  .withKey('student', 'alice')                             // AND: add key to last condition
+  .matchKey('course', 'cs101')                             // key-only (any event type)
+  .read();
+
+const result = await store.query<CourseEvent>()
+  .matchType('CourseCreated', 'CourseCancelled')           // multi-type
+  .andKey('course', 'cs101')                              // + key constraint
   .fromPosition(100n)                                      // start from position
   .limit(50)                                               // limit results
   .read();                                                 // execute, returns QueryResult
@@ -669,9 +630,10 @@ const result = await store.query<CourseEvent>()
 
 | Method | Description |
 |--------|-------------|
-| `matchType(type)` | Match all events of type (unconstrained) |
-| `matchTypeAndKey(type, key, value)` | Match events of type where key=value |
-| `withKey(key, value)` | Add AND key to last condition (multi-key) |
+| `matchKey(key, value)` | Match events by key, any type. Starts new condition (OR). |
+| `matchType(...types)` | Match events of type(s). Starts new condition (OR). |
+| `matchTypeAndKey(type, key, value)` | Shorthand for `matchType(type).andKey(key, value)` |
+| `andKey(key, value)` | Add AND key constraint to last condition |
 | `fromPosition(bigint)` | Start reading from position |
 | `limit(number)` | Limit number of results |
 | `read()` | Execute query, returns `QueryResult` |
@@ -796,4 +758,4 @@ For detailed SQL query plans and optimization notes, see [docs/sqlite-queries.md
 
 ---
 
-Built with ❤️ for [Event Sourcing](https://www.eventstore.com/event-sourcing)
+Built with ❤️ for Event Sourcing

package/dist/browser.d.ts

@@ -3,9 +3,9 @@
  *
  * This file exports everything needed for browser usage with sql.js storage.
  */
-export type { Event, EventWithMetadata, StoredEvent, Query, QueryCondition, UnconstrainedCondition, ConstrainedCondition, MultiKeyConstrainedCondition, ConsistencyConfig, ConsistencyKeyDef, EventTypeConfig, ExtractedKey, AppendResult, ConflictResult, AppendCondition, EventStoreOptions, } from './types.js';
-export { QueryResult, isConflict, isConstrainedCondition, isMultiKeyCondition, normalizeCondition, hasKeys } from './types.js';
-export { EventStore, createEventStore, type EventStoreConfig } from './event-store.browser.js';
+export type { Event, EventWithMetadata, StoredEvent, Query, QueryCondition, UnconstrainedCondition, ConstrainedCondition, MultiKeyConstrainedCondition, MultiTypeCondition, MultiTypeConstrainedCondition, KeyOnlyCondition, ConsistencyConfig, ConsistencyKeyDef, EventTypeConfig, ExtractedKey, AppendResult, ConflictResult, AppendCondition, EventStoreOptions, } from './types.js';
+export { QueryResult, isConflict, isConstrainedCondition, isMultiKeyCondition, isMultiTypeCondition, isMultiTypeConstrainedCondition, isKeyOnlyCondition, normalizeCondition, hasKeys } from './types.js';
+export { EventStore, createEventStore, type EventStoreConfig } from './event-store.js';
 export type { EventStorage, EventToStore } from './storage/interface.js';
 export { InMemoryStorage } from './storage/memory.js';
 export { SqlJsStorage, type SqlJsStorageOptions } from './storage/sqljs.js';

package/dist/browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EAEV,KAAK,EACL,iBAAiB,EACjB,WAAW,EAEX,KAAK,EACL,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,4BAA4B,EAE5B,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,YAAY,EAEZ,YAAY,EACZ,cAAc,EACd,eAAe,EACf,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG/H,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG/F,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG5E,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EAEV,KAAK,EACL,iBAAiB,EACjB,WAAW,EAEX,KAAK,EACL,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,4BAA4B,EAC5B,kBAAkB,EAClB,6BAA6B,EAC7B,gBAAgB,EAEhB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,YAAY,EAEZ,YAAY,EACZ,cAAc,EACd,eAAe,EACf,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1M,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGvF,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG5E,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/browser.js

@@ -3,9 +3,9 @@
  *
  * This file exports everything needed for browser usage with sql.js storage.
  */
-export { QueryResult, isConflict, isConstrainedCondition, isMultiKeyCondition, normalizeCondition, hasKeys } from './types.js';
+export { QueryResult, isConflict, isConstrainedCondition, isMultiKeyCondition, isMultiTypeCondition, isMultiTypeConstrainedCondition, isKeyOnlyCondition, normalizeCondition, hasKeys } from './types.js';
 // Event Store (browser version)
-export { EventStore, createEventStore } from './event-store.browser.js';
+export { EventStore, createEventStore } from './event-store.js';
 export { InMemoryStorage } from './storage/memory.js';
 export { SqlJsStorage } from './storage/sqljs.js';
 // Config

package/dist/browser.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA0BH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE/H,gCAAgC;AAChC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAyB,MAAM,0BAA0B,CAAC;AAI/F,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAA4B,MAAM,oBAAoB,CAAC;AAE5E,SAAS;AACT,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA6BH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1M,gCAAgC;AAChC,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAyB,MAAM,kBAAkB,CAAC;AAIvF,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAA4B,MAAM,oBAAoB,CAAC;AAE5E,SAAS;AACT,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/event-store.d.ts

@@ -19,7 +19,9 @@ export declare class EventStore {
     private readonly config;
     constructor(options: EventStoreConfig);
     /**
-     * Check if config has changed since last run, reindex if needed
+     * Check if config has changed since last run, reindex if needed.
+     * Works with any storage that implements getConfigHash/setConfigHash.
+     * Handles both sync (SqliteStorage) and async (SqlJsStorage) methods.
      */
     private checkAndReindexIfNeeded;
     /**

package/dist/event-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../src/event-store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,WAAW,EAKX,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,KAAK,EACV,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EAGX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAsB,MAAM,oBAAoB,CAAC;AA2BtE,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACzD,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,OAAO,EAAE,gBAAgB;IAYrC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAqB/B;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC;IAIjD;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC;IAI/C;;;;;;;;;;;;;;;;;;OAkBG;IACG,IAAI,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAqB1E;;;;;;;;;;;;;;;;;;;OAmBG;IACG,MAAM,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAClC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAC9B,SAAS,EAAE,eAAe,GAAG,IAAI,GAChC,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IA2D5C;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAkCjC;;OAEG;IACH,UAAU,IAAI,YAAY;IAI1B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU,CAEtE"}
+{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../src/event-store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,WAAW,EAKX,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,KAAK,EACV,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,KAAK,EAGX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAsB,MAAM,oBAAoB,CAAC;AAmDtE,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACzD,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,OAAO,EAAE,gBAAgB;IAYrC;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC;IAIjD;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,KAAK,YAAY,CAAC,CAAC,CAAC;IAI/C;;;;;;;;;;;;;;;;;;OAkBG;IACG,IAAI,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAqB1E;;;;;;;;;;;;;;;;;;;OAmBG;IACG,MAAM,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAClC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,EAC9B,SAAS,EAAE,eAAe,GAAG,IAAI,GAChC,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IA2D5C;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAmCjC;;OAEG;IACH,UAAU,IAAI,YAAY;IAI1B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU,CAEtE"}

package/dist/event-store.js

@@ -1,12 +1,28 @@
 /**
  * Main EventStore class
  */
-import { randomUUID, createHash } from 'node:crypto';
 import { KeyExtractor } from './config/extractor.js';
 import { validateConfig } from './config/validator.js';
-import { SqliteStorage } from './storage/sqlite.js';
 import { QueryResult, normalizeCondition, hasKeys, } from './types.js';
 import { QueryBuilder } from './query-builder.js';
+/**
+ * Generate UUID with fallback for environments without node:crypto
+ */
+function generateUUID() {
+    try {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+    }
+    catch {
+        // crypto.randomUUID might throw in insecure contexts
+    }
+    // Fallback: Math.random-based UUID v4
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0;
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+}
 /**
  * Recursively sort object keys for deterministic JSON
  */
@@ -24,11 +40,17 @@ function sortObjectKeys(obj) {
     return sorted;
 }
 /**
- * Compute SHA256 hash of ConsistencyConfig
+ * Compute a deterministic hash of ConsistencyConfig (FNV-1a).
+ * No crypto dependency — just needs to detect config changes.
  */
 function hashConfig(config) {
     const normalized = JSON.stringify(sortObjectKeys(config));
-    return createHash('sha256').update(normalized).digest('hex');
+    let hash = 0x811c9dc5; // FNV offset basis
+    for (let i = 0; i < normalized.length; i++) {
+        hash ^= normalized.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193); // FNV prime
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
 }
 /**
  * DCB-native Event Store
@@ -46,25 +68,40 @@ export class EventStore {
         this.storage = options.storage;
         this.config = options.consistency;
         this.keyExtractor = new KeyExtractor(this.config);
-        // Check config hash and reindex if needed (SqliteStorage only)
+        // Check config hash and throw on mismatch
         this.checkAndReindexIfNeeded();
     }
     /**
-     * Check if config has changed since last run, reindex if needed
+     * Check if config has changed since last run, reindex if needed.
+     * Works with any storage that implements getConfigHash/setConfigHash.
+     * Handles both sync (SqliteStorage) and async (SqlJsStorage) methods.
      */
     checkAndReindexIfNeeded() {
-        // Only works with SqliteStorage (has metadata table)
-        if (!(this.storage instanceof SqliteStorage)) {
+        const storage = this.storage;
+        if (typeof storage.getConfigHash !== 'function' || typeof storage.setConfigHash !== 'function') {
             return;
         }
         const currentHash = hashConfig(this.config);
-        const storedHash = this.storage.getConfigHash();
+        const result = storage.getConfigHash();
+        // Handle async storage (SqlJsStorage returns Promises)
+        if (result && typeof result.then === 'function') {
+            result.then((storedHash) => {
+                if (storedHash === null) {
+                    storage.setConfigHash(currentHash);
+                }
+                else if (storedHash !== currentHash) {
+                    console.error(`Config hash mismatch (stored: ${storedHash}, current: ${currentHash}). ` +
+                        `Run the reindex script before starting the application.`);
+                }
+            });
+            return;
+        }
+        // Sync storage (SqliteStorage)
+        const storedHash = result;
         if (storedHash === null) {
-            // First run — just store the hash
-            this.storage.setConfigHash(currentHash);
+            storage.setConfigHash(currentHash);
         }
         else if (storedHash !== currentHash) {
-            // Config changed — throw error, require explicit reindex via script
             throw new Error(`Config hash mismatch (stored: ${storedHash}, current: ${currentHash}). ` +
                 `Run the reindex script before starting the application.`);
         }
@@ -174,7 +211,7 @@ export class EventStore {
         // Prepare events for storage
         const now = new Date();
         const eventsToStore = events.map(event => ({
-            id: randomUUID(),
+            id: generateUUID(),
             type: event.type,
             data: event.data,
             metadata: event.metadata,
@@ -220,7 +257,8 @@ export class EventStore {
                 if (hasKeys(normalized)) {
                     // Build a dedup key from all keys
                     const keysStr = normalized.keys.map(k => `${k.name}:${k.value}`).sort().join('|');
-                    const dedupKey = `${normalized.type}:${keysStr}`;
+                    const typeStr = 'type' in normalized ? normalized.type : ('types' in normalized ? normalized.types.join('|') : '*');
+                    const dedupKey = `${typeStr}:${keysStr}`;
                     conditions.set(dedupKey, normalized);
                 }
             }