@ossy/event-store 1.8.2 → 3.0.1

package/README.md

@@ -1,46 +1,59 @@
 # @ossy/event-store
 
-Event sourcing primitives for the Ossy platform. Provides `Aggregate` (stream interaction), `EventStore` (raw event I/O), and `AggregateRebuild` (startup snapshot rebuilding) on top of MongoDB.
+Event sourcing primitives for the Ossy platform. Provides `Aggregate` (ADR 0008 entity streams), `EventStore` (resource event I/O), `ProjectionRebuild` / `getProjection` (derived read models), `PushInvalidation` (SSE cache invalidation), and `AggregateRebuild` (startup snapshot rebuilding) on top of MongoDB.
+
+## Exports
+
+| Export | Module | Purpose |
+|--------|--------|---------|
+| `Mongo` | `mongodb.js` | Connect to MongoDB |
+| `Aggregate` | `aggregate.js` | Entity stream facade (delegates to `SchemaStream`) |
+| `SchemaStream` | `schema-stream.js` | Low-level ADR 0008 entity stream I/O |
+| `EventStore` | `event-store.js` | Append and query resource events |
+| `AggregateRebuild` | `aggregate-rebuild.js` | Startup snapshot rebuild for entities and resources |
+| `ProjectionRebuild` | `projection-rebuild.js` | Incremental and full projection rebuild |
+| `getProjection` | `projection-queries.js` | Read a projection snapshot by scope |
+| `PushInvalidation` | `push-invalidation.js` | Workspace-scoped SSE fan-out |
+| `buildInvalidationKeys`, `buildPushMessage` | `push-invalidation.js` | Derive client cache keys from events |
 
 ## Core concepts
 
 The event store keeps two MongoDB collections:
 
-- **`eventstore`** — every event ever appended. Immutable. Each document is one domain event with `aggregateId`, `aggregateType`, `aggregateVersion`, `type`, `payload`, `created`, and `createdBy`.
-- **`aggregates`** — denormalized state snapshots, rebuilt from the event stream. Used for fast queries. Rebuilt automatically at startup and kept up-to-date as new events arrive.
+- **`eventstore`** — every resource/entity event ever appended. Immutable. ADR 0008 documents use `type` (schema id), `resourceId`, `event` (lifecycle name), `version`, `payload`, `created`, and `createdBy`.
+- **`aggregates`** — denormalized state snapshots: entity/resource folds keyed by `id`, and projection snapshots keyed by `{ id: scopeId, type: projectionId, kind: 'projection' }`. Rebuilt at startup and updated on the changestream.
 
 ---
 
 ## `Aggregate`
 
-The main entry point for reading and writing event streams. All methods return Promises and are chainable with `.then()`.
+Facade over `SchemaStream` for entity aggregates that declare `static SchemaId`. All methods return Promises.
 
 ### Reading the current state
 
 ```js
 import { Aggregate } from '@ossy/event-store'
-import { Order } from '@acme/orders'
+import { User } from '@ossy/users/server'
 
-// Fold all events for `orderId` through Order.View() and return the result
-const state = await Aggregate.Of(Order, orderId).then(Aggregate.View())
+const state = await Aggregate.Of(User, userId).then(Aggregate.View())
 ```
 
-### Creating a new aggregate
+### Creating a new entity
 
-Pass an event object as the identifier. The event is appended and the new aggregate is returned.
+Pass a creation event as the identifier. The event is appended and the stream is returned.
 
 ```js
-const newOrderEvent = { type: 'OrderPlaced', createdBy: userId, payload: { ... } }
-const orderView = await Aggregate.Of(Order, newOrderEvent).then(Aggregate.View())
+const createdEvent = UsersEvents.Created({ email, firstName, lastName })
+const userView = await Aggregate.Of(User, createdEvent).then(Aggregate.View())
 ```
 
-An `aggregateId` inside the event is used as the aggregate's id; if absent, a `nanoid()` is generated.
+`resourceId` in the event is the entity id; if absent, the event factory generates one.
 
-### Appending an event to an existing aggregate
+### Appending to an existing entity
 
 ```js
-await Aggregate.Of(Order, orderId)
-  .then(Aggregate.Add({ type: 'OrderShipped', createdBy: userId, payload: { shippedAt: Date.now() } }))
+await Aggregate.Of(User, userId)
+  .then(Aggregate.Add(UsersEvents.NameUpdated({ firstName, lastName, createdBy: userId })))
   .then(Aggregate.Save())
 ```
 
@@ -48,117 +61,113 @@ await Aggregate.Of(Order, orderId)
 
 | Method | Signature | Description |
 |---|---|---|
-| `Aggregate.Of(Root, id)` | `(class, string) => Promise<Aggregate>` | Load an existing aggregate from the event store. |
-| `Aggregate.Of(Root, event)` | `(class, object) => Promise<Aggregate>` | Create a new aggregate by appending the first event. |
-| `Aggregate.Add(event)` | `(event) => (aggregate) => Promise<Aggregate>` | Append an event to the aggregate. Chainable. |
-| `Aggregate.Save()` | `() => (aggregate) => Promise<void>` | Persist the current state snapshot to the `aggregates` collection. |
-| `Aggregate.View(fn?)` | `(fn?) => (aggregate) => state` | Call the aggregate's `View(events, savedState)` and return the result. Pass a custom view function to override. |
-| `Aggregate.Validate(fn)` | `(fn) => (aggregate) => Promise<Aggregate>` | Run a validation function against `(events, savedState)`. Reject if the function throws. |
-| `Aggregate.Find(id)` | `(string) => Promise<object \| null>` | Low-level: find the snapshot document in `aggregates` by id. |
+| `Aggregate.Of(Root, id)` | `(class, string) => Promise<Stream>` | Load an entity stream by `resourceId`. |
+| `Aggregate.Of(Root, event)` | `(class, object) => Promise<Stream>` | Create a new entity by appending the first event. |
+| `Aggregate.Add(event)` | `(event) => (stream) => Promise<Stream>` | Append an event. Chainable. |
+| `Aggregate.Save()` | `() => (stream) => Promise<void>` | Persist the folded snapshot to `aggregates`. |
+| `Aggregate.View(fn?)` | `(fn?) => (stream) => state` | Fold events through the aggregate `View` reducer. |
+| `Aggregate.Validate(fn)` | `(fn) => (stream) => Promise<Stream>` | Run validation against `(events, savedState)`. |
+| `Aggregate.Find(id)` | `(string) => Promise<object \| null>` | Find a snapshot document in `aggregates` by id. |
 | `Aggregate.Collection` | `Collection` | Direct access to the MongoDB `aggregates` collection. |
 
+Entity aggregate classes require `static SchemaId` (ADR 0008). Resource documents use `@ossy/resources` `commitResource` / `mutateResource` instead.
+
 ---
 
-## Writing an aggregate class
+## `EventStore`
 
-An aggregate class is a pure reducer — no side effects, no I/O. It declares a `static AggregateType` string and a `static View(events, savedState)` function.
+Low-level access to the `eventstore` collection.
 
 ```js
-// src/order.aggregate.js  (inside an installable package)
-export class Order {
-  static AggregateType = 'Order'
-
-  /**
-   * Folds an array of events into the current state.
-   * @param {object[]} events    - Event documents in ascending version order.
-   * @param {object}   savedState - Last saved snapshot (can be empty object).
-   * @returns {object}
-   */
-  static View(events, savedState = {}) {
-    return events.reduce((state, event) => {
-      switch (event.type) {
-        case 'OrderPlaced':
-          return { ...state, id: event.aggregateId, status: 'pending', ...event.payload }
-        case 'OrderShipped':
-          return { ...state, status: 'shipped', shippedAt: event.created }
-        case 'OrderCancelled':
-          return { ...state, status: 'cancelled' }
-        default:
-          return state
-      }
-    }, savedState)
-  }
-}
-
-// Required exports for the *.aggregate.js primitive
-export { Order as Aggregate }
-export const id = 'Order'  // must equal Order.AggregateType
+import { EventStore } from '@ossy/event-store'
 ```
 
-> Aggregate files must be in an **installable package** (a `node_modules/` package with `"ossy": { "src": "./src" }` in `package.json`). The platform never loads aggregates from the local app's `src/` to avoid duplicates.
+| Method | Signature | Description |
+|---|---|---|
+| `EventStore.AppendResourceEvent(event)` | `(object) => Promise<object>` | Insert an ADR 0008 event document. |
+| `EventStore.GetResourceStream({ resourceId, fromVersion? })` | `=> Promise<object[]>` | Events for one `resourceId`, optionally after a version. |
+| `EventStore.GetResourceStreams()` | `=> Promise<{ resourceId, type }[]>` | All known `(resourceId, schemaId)` pairs. |
+| `EventStore.FindEvent(query)` | `(MongoQuery) => Promise<object>` | Find a single event. Rejects when not found. |
+| `EventStore.FindEvents(query)` | `(MongoQuery) => Promise<object[]>` | Find multiple events. Rejects when none found. |
+| `EventStore.Aggregate(pipeline)` | `(Pipeline) => Promise<object[]>` | Run a MongoDB aggregation pipeline. |
+| `EventStore.Collection` | `Collection` | Direct access to the `eventstore` collection. |
 
 ---
 
-## `EventStore`
+## Projections
 
-Low-level access to the `eventstore` collection. Prefer using `Aggregate` for most work.
+Projection aggregates (`kind: 'projection'`) fold resource events into scope-keyed read models (e.g. workspace booking list).
 
 ```js
-import { EventStore } from '@ossy/event-store'
+import { getProjection } from '@ossy/event-store'
+
+const list = await getProjection(workspaceId, '@ossy/booking/data/booking-list')
 ```
 
-| Method | Signature | Description |
-|---|---|---|
-| `EventStore.AppendEvent(event)` | `(object) => Promise<object>` | Insert an event document. Rejects on failure. |
-| `EventStore.GetEventStream({ aggregateId, fromVersion? })` | `=> Promise<object[]>` | Return all events for an aggregate id, optionally after a version. |
-| `EventStore.GetEventStreams()` | `=> Promise<{ aggregateId, aggregateType }[]>` | Return all known `(aggregateId, aggregateType)` pairs. |
-| `EventStore.FindEvent(query)` | `(MongoQuery) => Promise<object>` | Find a single event. Rejects when not found. |
-| `EventStore.FindEvents(query)` | `(MongoQuery) => Promise<object[]>` | Find multiple events. Rejects when none found. |
-| `EventStore.Aggregate(pipeline)` | `(Pipeline) => Promise<object[]>` | Run a MongoDB aggregation pipeline against the event store. |
-| `EventStore.Collection` | `Collection` | Direct access to the MongoDB `eventstore` collection. |
+| API | Description |
+|-----|-------------|
+| `ProjectionRebuild.registerProjection({ id, Aggregate })` | Register a projection class (also called via `AggregateRebuild.registerAggregate` when `kind === 'projection'`) |
+| `ProjectionRebuild.dispatch(event)` | Apply one changestream event to matching projections |
+| `ProjectionRebuild.rebuildAll()` | Replay source events at startup (called from `AggregateRebuild.BuildAndSaveAll()`) |
+
+Projection classes declare `static sources`, `static scopeFromEvent(event)`, `static Apply(event, state)`, and optionally `static cacheKeys(scopeId, event)`.
+
+---
+
+## Push invalidation (ADR 0008 §9)
+
+After changestream rebuild, `PushInvalidation.publish(event)` fans out SSE messages to workspace subscribers.
+
+- **Server:** `GET /events` (workspace-scoped via `workspaceId` header or user settings cookie)
+- **Client:** `sdk.subscribePush({ onMessage })` — opt in via `PushInvalidationSubscriber` or `enablePushInvalidation` in app config (off by default; see [@ossy/sdk-react README](../sdk-react/README.md#push-invalidation))
+- **Keys:** `resource:{id}`, `location:{path}`, `projection:{id}:{scopeId}`, `action:{actionId}`
+
+Use `buildInvalidationKeys(event)` to derive keys server-side; `buildPushMessage(event)` wraps them for SSE payloads. Projection aggregates may define `static cacheKeys(scopeId, event)` for bespoke list-action keys.
 
 ---
 
 ## `AggregateRebuild`
 
-Rebuilds state snapshots from scratch at startup. Called automatically by `@ossy/platform` — you rarely need to use this directly.
+Rebuilds entity/resource snapshots from scratch at startup. Called automatically by `@ossy/platform`.
 
 ```js
 import { AggregateRebuild } from '@ossy/event-store'
 
-// Register an aggregate class (done automatically by the platform)
-AggregateRebuild.registerAggregate({ id: 'Order', Aggregate: Order })
-
-// Rebuild and save every known aggregate of every registered type
+AggregateRebuild.registerAggregate({ id: 'User', Aggregate: User })
 await AggregateRebuild.BuildAndSaveAll()
-
-// Rebuild a single aggregate
-await AggregateRebuild.BuildAndSave('Order', orderId)
 ```
 
+`registerAggregate` routes projection modules (`Aggregate.kind === 'projection'`) to `ProjectionRebuild`. Entity classes are indexed by `Aggregate.SchemaId` for resource rebuilds.
+
 ---
 
 ## `*.aggregate.js` primitive
 
-The platform auto-discovers aggregate files from installed packages. See [PRIMITIVES.md](../platform/PRIMITIVES.md#aggregate) for the full specification.
+The platform auto-discovers aggregate files from installed packages. Entity aggregates export `{ id, Aggregate }` with `Aggregate.SchemaId`; projection aggregates set `Aggregate.kind = 'projection'`. See [PRIMITIVES.md](../platform/PRIMITIVES.md#aggregate).
 
 ---
 
 ## MongoDB setup
 
-Connect to MongoDB before using any `Aggregate` or `EventStore` methods:
-
 ```js
 import { Mongo } from '@ossy/event-store'
 
 await Mongo.connect(process.env.DB_URL)
 ```
 
-The platform server calls `Mongo.connect` automatically when `DB_URL` is present in the environment.
-
-Indexes recommended for the `eventstore` collection:
+Recommended indexes for `eventstore`:
 
 ```js
-{ aggregateId: 1, aggregateVersion: 1 }  // stream queries
-{ aggregateType: 1 }                      // type-level queries
+{ resourceId: 1, version: 1 }  // stream queries
+{ type: 1, event: 1 }          // projection replay / task triggers
+```
+
+---
+
+## Testing
+
+```bash
+npm test -w @ossy/event-store
 ```
+
+Runs unit tests for push invalidation key derivation (`push-invalidation.spec.js`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "1.8.2",
+  "version": "3.0.1",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -19,16 +19,23 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "keywords": [],
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --verbose"
+  },
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/observability": "^1.8.2",
+    "@ossy/fold": "^3.0.1",
+    "@ossy/observability": "^3.0.1",
     "mongodb": "^7.2.0",
     "nanoid": "^5.1.11"
   },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "jest": "^30.2.0"
+  },
   "files": [
     "src"
   ],
-  "gitHead": "2b8745d57fee8b6c08787e2755b4df489291a5cd"
+  "gitHead": "4a70ec216448680d2fddc57b2a8a0077489720ae"
 }

package/src/aggregate-rebuild.js

@@ -1,65 +1,127 @@
-import { Aggregate } from './aggregate.js'
-import { EventStore } from './event-store.js'
+import { EventStore, getResourceStream } from './event-store.js'
+import { SchemaStream } from './schema-stream.js'
+import { ProjectionRebuild } from './projection-rebuild.js'
+import { withMongoReconnect } from './mongodb.js'
+import { createDefaultReducer } from '@ossy/fold'
 import { createLogger } from '@ossy/observability'
 
 const log = createLogger('event-store')
 
 export class AggregateRebuild {
 
-    /** @type {Record<string, Function>} */
-    static _aggregateMap = {}
-
-    /**
-     * Registers a pre-loaded aggregate module. Called by the platform server at
-     * startup for each aggregate entry in the manifest, following the same pattern
-     * as task and resource-template registration.
-     *
-     * @param {{ id: string, Aggregate: Function }} mod - The aggregate bundle module.
-     */
-    static registerAggregate(mod) {
-        const { id, Aggregate: AggregateClass } = mod
-        if (typeof AggregateClass !== 'function' || !id) {
-            log.warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
-            return
-        }
-        AggregateRebuild._aggregateMap[id] = AggregateClass
-        log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
+  /** @type {Record<string, Function>} */
+  static _aggregateMap = {}
+
+  /** @type {Record<string, Function>} */
+  static _schemaMap = {}
+
+  /**
+   * @param {{ id: string, Aggregate: Function }} mod
+   */
+  static registerAggregate (mod) {
+    const { id, Aggregate: AggregateClass } = mod
+    if (typeof AggregateClass !== 'function' || !id) {
+      log.warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
+      return
+    }
+    AggregateRebuild._aggregateMap[id] = AggregateClass
+    if (AggregateClass.SchemaId) {
+      AggregateRebuild._schemaMap[AggregateClass.SchemaId] = AggregateClass
+    }
+    if (AggregateClass.kind === 'projection') {
+      ProjectionRebuild.registerProjection(mod)
+      return
     }
+    log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
+  }
+
+  /**
+   * Incrementally update an entity snapshot — same semantics as `SchemaStream.Of` + `Save`.
+   *
+   * @param {string} resourceId
+   * @param {string} [schemaId]
+   * @param {{ event?: object }} [options] changestream trigger event (avoids re-query when next in sequence)
+   */
+  static async BuildAndSaveResource (resourceId, schemaId, options = {}) {
+    const { event: triggerEvent } = options
+    const AggregateRoot = schemaId ? AggregateRebuild._schemaMap[schemaId] : null
+    const snapshot = await SchemaStream.Find(resourceId)
+    const fromVersion = snapshot?.version ?? 0
+
+    const events = await AggregateRebuild._loadTailEvents({
+      resourceId,
+      fromVersion,
+      triggerEvent,
+    })
+
+    if (!events.length) return
 
-    static async BuildAndSave(aggregateType, aggregateId) {
-        const AggregateRoot = AggregateRebuild._aggregateMap[aggregateType]
+    const state = AggregateRoot
+      ? AggregateRoot.View(events, snapshot?.state)
+      : createDefaultReducer()(events, snapshot?.state)
 
-        if (!AggregateRoot) {
-            log.debug(`[AggregateRebuild][BuildAndSave] Skipping unregistered aggregate type: ${aggregateType}`)
-            return
-        }
+    const type = schemaId ?? state?.type ?? events[0]?.type ?? snapshot?.type
+    const version = events[events.length - 1].version
 
-        return Aggregate.Of(AggregateRoot, aggregateId)
-            .then(Aggregate.Save())
+    return withMongoReconnect(() =>
+      SchemaStream.Collection.updateOne(
+        { id: resourceId },
+        { $set: { id: resourceId, version, type, state } },
+        { upsert: true },
+      ),
+    )
+  }
+
+  /**
+   * @param {{ resourceId: string, fromVersion: number, triggerEvent?: object }} opts
+   * @returns {Promise<object[]>}
+   */
+  static async _loadTailEvents ({ resourceId, fromVersion, triggerEvent }) {
+    if (
+      triggerEvent?.resourceId === resourceId &&
+      triggerEvent.version === fromVersion + 1
+    ) {
+      return [triggerEvent]
     }
 
-    static async BuildAndSaveAll() {
-        log.debug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
-
-        const knownTypes = new Set(Object.keys(AggregateRebuild._aggregateMap))
-
-        if (knownTypes.size === 0) {
-            log.warn('[AggregateRebuild][BuildAndSaveAll] No aggregates registered — skipping rebuild')
-            return
-        }
-
-        return EventStore.GetEventStreams()
-            .then(streams => Promise.allSettled(
-                streams
-                    .filter(({ aggregateType }) => knownTypes.has(aggregateType))
-                    .map(({ aggregateType, aggregateId }) => AggregateRebuild.BuildAndSave(aggregateType, aggregateId))
-            ))
-            .then(results => {
-                const failed = results.filter(result => result.status === 'rejected')
-                const success = results.filter(result => result.status === 'fulfilled')
-                log.info('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
-                log.info(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
-                log.info(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
-            })
+    return getResourceStream({ resourceId, fromVersion })
+  }
+
+  static async BuildAndSaveAll () {
+    log.debug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
+
+    if (Object.keys(AggregateRebuild._schemaMap).length === 0) {
+      log.warn('[AggregateRebuild][BuildAndSaveAll] No schema aggregates registered — skipping rebuild')
+      return
     }
+
+    return EventStore.GetResourceStreams()
+      .then(streams => Promise.allSettled(
+        streams.map(({ resourceId, type }) => AggregateRebuild.BuildAndSaveResource(resourceId, type)),
+      ))
+      .then(async results => {
+        await ProjectionRebuild.rebuildAll()
+        const failed = results.filter(r => r.status === 'rejected')
+        const success = results.filter(r => r.status === 'fulfilled')
+        log.info('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
+        log.info(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
+        log.info(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
+      })
+  }
+}
+
+/**
+ * Pure helper — pick tail events for incremental rebuild (exported for tests).
+ *
+ * @param {{ fromVersion: number, triggerEvent?: object, resourceId: string, fetchedTail: object[] }} opts
+ * @returns {object[]}
+ */
+export function selectTailEventsForRebuild ({ resourceId, fromVersion, triggerEvent, fetchedTail }) {
+  if (
+    triggerEvent?.resourceId === resourceId &&
+    triggerEvent.version === fromVersion + 1
+  ) {
+    return [triggerEvent]
+  }
+  return fetchedTail
 }

package/src/aggregate-rebuild.spec.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from '@jest/globals'
+import { selectTailEventsForRebuild } from './aggregate-rebuild.js'
+
+describe('selectTailEventsForRebuild', () => {
+  const resourceId = 'res_1'
+
+  it('uses the changestream trigger event when it is the next version', () => {
+    const triggerEvent = { resourceId, version: 3, event: 'Updated' }
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 2,
+      triggerEvent,
+      fetchedTail: [{ resourceId, version: 3 }],
+    })
+    expect(result).toEqual([triggerEvent])
+  })
+
+  it('uses fetched tail when trigger is not the immediate next version', () => {
+    const fetchedTail = [
+      { resourceId, version: 3 },
+      { resourceId, version: 4 },
+    ]
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 2,
+      triggerEvent: { resourceId, version: 4, event: 'Updated' },
+      fetchedTail,
+    })
+    expect(result).toEqual(fetchedTail)
+  })
+
+  it('uses fetched tail when no trigger event is provided', () => {
+    const fetchedTail = [{ resourceId, version: 1 }]
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 0,
+      fetchedTail,
+    })
+    expect(result).toEqual(fetchedTail)
+  })
+})
+
+describe('incremental rebuild semantics', () => {
+  it('folds only tail events onto snapshot state', () => {
+    const View = (events, state = {}) =>
+      events.reduce((acc, e) => ({ ...acc, count: (acc.count ?? 0) + 1, last: e.event }), state)
+
+    const snapshot = { version: 2, state: { count: 2, last: 'Created' } }
+    const tail = [{ version: 3, event: 'Updated' }]
+    const next = View(tail, snapshot.state)
+
+    expect(next).toEqual({ count: 3, last: 'Updated' })
+  })
+})

package/src/aggregate-rebuild.task.js

@@ -1,13 +1,19 @@
-import { AggregateRebuild } from '@ossy/event-store'
+import { AggregateRebuild } from './aggregate-rebuild.js'
+
+/** Platform audit envelopes have no entity aggregate snapshot — handled inline on the changestream. */
+const PLATFORM_AUDIT_TYPES = [
+  '@ossy/platform/schema/task-run',
+  '@ossy/platform/schema/action-invocation',
+  '@ossy/platform/schema/meter-event',
+]
 
 export const metadata = {
-  id: 'aggregate-rebuild',
-  // Empty trigger matches all events. AggregateRebuild.BuildAndSave silently
-  // skips any aggregateType not registered in the manifest, so only events
-  // for known aggregate types result in a rebuild.
-  triggers: [{}]
+  id: '@ossy/event-store/tasks/aggregate-rebuild',
+  triggers: [{ excludeTypes: PLATFORM_AUDIT_TYPES }],
 }
 
 export async function run ({ event }) {
-  await AggregateRebuild.BuildAndSave(event.aggregateType, event.aggregateId)
+  if (!event?.resourceId) return
+
+  await AggregateRebuild.BuildAndSaveResource(event.resourceId, event.type, { event })
 }