@schemeless/event-store-types 5.0.0 → 6.0.0-rc.1

package/dist/Errors.d.ts

@@ -1,47 +1,13 @@
-export declare class ConcurrencyError extends Error {
-    readonly streamKey: string;
-    readonly expectedSequence: number;
-    readonly actualSequence: number;
-    constructor(streamKey: string, expectedSequence: number, actualSequence: number);
-}
 export declare class EventStoreError extends Error {
     constructor(message: string);
 }
-export declare class ValidationError extends EventStoreError {
-    readonly flow: {
-        domain: string;
-        type: string;
-    };
-    readonly eventId: string;
-    readonly cause: Error;
-    constructor(flow: {
-        domain: string;
-        type: string;
-    }, eventId: string, cause: Error);
-}
-export declare class FlowNotFoundError extends EventStoreError {
+export declare class StreamConcurrencyError extends EventStoreError {
     readonly domain: string;
-    readonly type: string;
-    constructor(domain: string, type: string);
-}
-export declare class AggregateError extends EventStoreError {
-    readonly flow: {
-        domain: string;
-        type: string;
-    };
-    readonly reason: 'no_loader' | 'no_identifier' | 'apply_must_return_state' | 'capability_missing';
-    constructor(flow: {
-        domain: string;
-        type: string;
-    }, reason: 'no_loader' | 'no_identifier' | 'apply_must_return_state' | 'capability_missing');
+    readonly identifier: string;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    constructor(domain: string, identifier: string, expectedVersion: number, actualVersion: number);
 }
-export declare class ShutdownTimeoutError extends EventStoreError {
-    readonly timeoutMs: number;
-    constructor(timeoutMs: number);
-}
-export declare class RevertError extends EventStoreError {
-    readonly eventId: string;
-    readonly reason: 'not_found' | 'not_root' | 'missing_compensate' | 'repo_not_supported';
-    readonly details?: string;
-    constructor(eventId: string, reason: 'not_found' | 'not_root' | 'missing_compensate' | 'repo_not_supported', details?: string);
+export declare class SnapshotError extends EventStoreError {
+    constructor(message: string);
 }

package/dist/Errors.js

@@ -1,16 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RevertError = exports.ShutdownTimeoutError = exports.AggregateError = exports.FlowNotFoundError = exports.ValidationError = exports.EventStoreError = exports.ConcurrencyError = void 0;
-class ConcurrencyError extends Error {
-    constructor(streamKey, expectedSequence, actualSequence) {
-        super(`Concurrency conflict on stream "${streamKey}": expected sequence ${expectedSequence}, but found ${actualSequence}`);
-        this.streamKey = streamKey;
-        this.expectedSequence = expectedSequence;
-        this.actualSequence = actualSequence;
-        this.name = 'ConcurrencyError';
-    }
-}
-exports.ConcurrencyError = ConcurrencyError;
+exports.SnapshotError = exports.StreamConcurrencyError = exports.EventStoreError = void 0;
 class EventStoreError extends Error {
     constructor(message) {
         super(message);
@@ -18,62 +8,21 @@ class EventStoreError extends Error {
     }
 }
 exports.EventStoreError = EventStoreError;
-class ValidationError extends EventStoreError {
-    constructor(flow, eventId, cause) {
-        super(`Validation failed for ${flow.domain}/${flow.type} (event ${eventId}): ${cause.message}`);
-        this.flow = flow;
-        this.eventId = eventId;
-        this.cause = cause;
-        this.name = 'ValidationError';
-    }
-}
-exports.ValidationError = ValidationError;
-class FlowNotFoundError extends EventStoreError {
-    constructor(domain, type) {
-        super(`No EventFlow registered for "${domain}/${type}". ` +
-            `Make sure the EventFlow is included in the eventFlows array passed to makeEventStore.`);
+class StreamConcurrencyError extends EventStoreError {
+    constructor(domain, identifier, expectedVersion, actualVersion) {
+        super(`Concurrency conflict on stream "${domain}/${identifier}": expected version ${expectedVersion}, but found ${actualVersion}`);
         this.domain = domain;
-        this.type = type;
-        this.name = 'FlowNotFoundError';
-    }
-}
-exports.FlowNotFoundError = FlowNotFoundError;
-class AggregateError extends EventStoreError {
-    constructor(flow, reason) {
-        const messages = {
-            no_loader: 'requires getAggregate() support to load state',
-            no_identifier: 'requires an identifier (set event.identifier or aggregate.getIdentifier)',
-            apply_must_return_state: 'apply() must return the new state object',
-            capability_missing: 'requires adapter with getStreamEvents() support',
-        };
-        super(`AggregateEventFlow ${flow.domain}/${flow.type}: ${messages[reason]}`);
-        this.flow = flow;
-        this.reason = reason;
-        this.name = 'AggregateError';
-    }
-}
-exports.AggregateError = AggregateError;
-class ShutdownTimeoutError extends EventStoreError {
-    constructor(timeoutMs) {
-        super(`EventStore shutdown timed out after ${timeoutMs}ms`);
-        this.timeoutMs = timeoutMs;
-        this.name = 'ShutdownTimeoutError';
+        this.identifier = identifier;
+        this.expectedVersion = expectedVersion;
+        this.actualVersion = actualVersion;
+        this.name = 'StreamConcurrencyError';
     }
 }
-exports.ShutdownTimeoutError = ShutdownTimeoutError;
-class RevertError extends EventStoreError {
-    constructor(eventId, reason, details) {
-        const messages = {
-            not_found: `Event not found: ${eventId}`,
-            not_root: `Event ${eventId} is not a root event. Revert the root event instead.`,
-            missing_compensate: `Some events in the tree lack a 'compensate' hook`,
-            repo_not_supported: 'Repository must implement getEventById and findByCausationId',
-        };
-        super(messages[reason] + (details ? `. ${details}` : ''));
-        this.eventId = eventId;
-        this.reason = reason;
-        this.details = details;
-        this.name = 'RevertError';
+exports.StreamConcurrencyError = StreamConcurrencyError;
+class SnapshotError extends EventStoreError {
+    constructor(message) {
+        super(message);
+        this.name = 'SnapshotError';
     }
 }
-exports.RevertError = RevertError;
+exports.SnapshotError = SnapshotError;

package/dist/EventStore.types.d.ts

@@ -1,172 +1,25 @@
-/**
- * Base metadata for all events.
- * Framework automatically populates schemaVersion.
- * User code can extend this interface for custom metadata.
- */
 export interface EventMeta {
-    /** Schema version of the event payload */
     schemaVersion?: number;
-    /** Flag indicating this is a compensating event */
-    isCompensating?: boolean;
-    /** ID of the event being compensated */
-    compensatesEventId?: string;
-    /** Allow arbitrary extensions */
     [key: string]: any;
 }
-export interface BaseEventInput<Payload, META extends EventMeta = EventMeta> {
+export interface BaseEventInput<Payload = any, META extends EventMeta = EventMeta> {
     payload: Payload;
     meta?: META;
     identifier?: string;
     correlationId?: string;
-    /**
-     * @deprecated Will be removed in v3.0.
-     * causationId is now managed exclusively by the framework.
-     * Do not set this field manually.
-     */
     causationId?: string;
     created?: Date;
 }
-export interface BaseEvent<Payload, META extends EventMeta = EventMeta> extends BaseEventInput<Payload, META> {
+export interface BaseEvent<Payload = any, META extends EventMeta = EventMeta> extends BaseEventInput<Payload, META> {
     id?: string;
     domain: string;
     type: string;
-    payload: Payload;
-    identifier?: string;
-    correlationId?: string;
-    causationId?: string;
-    created?: Date;
 }
-export interface CreatedEvent<Payload, META extends EventMeta = EventMeta> extends BaseEvent<Payload, META> {
+export interface CreatedEvent<Payload = any, META extends EventMeta = EventMeta> extends BaseEvent<Payload, META> {
     id: string;
-    readonly created: Date;
+    created: Date;
 }
-export interface StoredEvent<Payload, META extends EventMeta = EventMeta> extends CreatedEvent<Payload, META> {
+export interface StoredEvent<Payload = any, META extends EventMeta = EventMeta> extends CreatedEvent<Payload, META> {
+    sequence?: number;
 }
 export type Event<Payload, META extends EventMeta = EventMeta> = StoredEvent<Payload, META>;
-export interface EventFlow<PartialPayload = any, Payload extends PartialPayload = PartialPayload, META extends EventMeta = EventMeta> {
-    readonly kind?: 'simple';
-    readonly domain: string;
-    readonly type: string;
-    readonly description?: string;
-    readonly meta?: {
-        readonly sideEffectFailedRetryAllowed?: number;
-    };
-    readonly eventType?: CreatedEvent<Payload, META>;
-    readonly payloadType?: PartialPayload | Payload;
-    readonly samplePayload?: PartialPayload | Payload;
-    /**
-     * Current schema version for this event type.
-     * Stored in event.meta.schemaVersion when event is created.
-     * @default 1
-     */
-    readonly schemaVersion?: number;
-    /**
-     * Upgrades event payload from older versions to the current schemaVersion.
-     * Called automatically during event processing and replay.
-     *
-     * @param event - The event with potentially outdated payload
-     * @param fromVersion - The version stored in event.meta.schemaVersion (defaults to 1)
-     * @returns Updated event with migrated payload, or void to use the original
-     */
-    readonly upcast?: (event: CreatedEvent<any, META>, fromVersion: number) => CreatedEvent<Payload, META> | Promise<CreatedEvent<Payload, META>> | void;
-    /**
-     * Extract the shard key for event routing.
-     * Events with the same shard key will be processed sequentially in the same partition.
-     * Events with different shard keys can be processed in parallel.
-     *
-     * @param event - The event to extract the shard key from
-     * @returns The shard key string, or undefined to use fallback (identifier)
-     * @example
-     * getShardKey: (event) => event.payload.userId
-     */
-    readonly getShardKey?: (event: BaseEvent<Payload, META>) => string | undefined;
-    /**
-     * @deprecated The `receive` pattern will be replaced in v5.
-     * Instead of `const send = MyEvent.receive(eventStore); await send(input);`
-     * use `await eventStore.submit(MyEvent, input);` directly.
-     */
-    readonly receive: (eventStore: {
-        receive: (eventFlow: EventFlow<PartialPayload, Payload, META>) => (eventInput: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
-    }) => (eventInputArgs: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
-    readonly validate?: (event: CreatedEvent<Payload, META>) => Promise<Error | void> | Error | void;
-    readonly preApply?: (event: CreatedEvent<PartialPayload, META>) => Promise<CreatedEvent<Payload, META> | void> | CreatedEvent<Payload, META> | void;
-    readonly apply?: (event: CreatedEvent<Payload, META>) => Promise<void> | void;
-    readonly sideEffect?: (event: CreatedEvent<Payload, META>) => Promise<void | BaseEvent<any>[]> | void | BaseEvent<any>[];
-    readonly cancelApply?: (event: CreatedEvent<Payload, META>) => Promise<void> | void;
-    readonly createConsequentEvents?: (causalEvent: CreatedEvent<Payload, META>) => Promise<BaseEvent<any>[]> | BaseEvent<any>[];
-    /**
-     * Generates compensating event(s) to reverse this event's effects.
-     * Called by the framework during revert operations.
-     *
-     * If this hook is not defined, the event cannot be reverted.
-     * If any event in a causal chain lacks this hook, the entire chain
-     * cannot be reverted.
-     *
-     * @param originalEvent - The event being reverted
-     * @returns Compensating event(s) to persist
-     */
-    readonly compensate?: (originalEvent: CreatedEvent<Payload, META>) => BaseEvent<any> | BaseEvent<any>[];
-}
-export interface AggregateConfig<State> {
-    readonly reducer: (state: State, event: CreatedEvent<any>) => State;
-    readonly initialState: State;
-    readonly getIdentifier?: (event: BaseEvent<any>) => string | undefined;
-}
-export interface AggregateEventFlow<PartialPayload = any, Payload extends PartialPayload = PartialPayload, State = any, META extends EventMeta = EventMeta> extends Omit<EventFlow<PartialPayload, Payload, META>, 'validate' | 'apply' | 'kind'> {
-    readonly kind?: 'aggregate';
-    readonly aggregate: AggregateConfig<State>;
-    readonly validate?: (event: CreatedEvent<Payload, META>, state: State) => Promise<Error | void> | Error | void;
-    readonly apply?: (event: CreatedEvent<Payload, META>, state: State) => State | Promise<State>;
-}
-export interface AggregateEventObserver<Payload = any, State = any> extends Omit<SuccessEventObserver<Payload>, 'apply'> {
-    readonly aggregate: true;
-    readonly apply?: (event: CreatedEvent<Payload>, state: State) => Promise<void> | void;
-}
-export type EventTaskAndError = {
-    task: CreatedEvent<any>;
-    error: Error;
-};
-export interface EventFlowMap {
-    [key: string]: EventFlow;
-}
-interface EventObserverStaticFilter {
-    domain: string;
-    type: string;
-}
-type EventObserverFilter = EventObserverStaticFilter;
-export interface SuccessEventObserver<Payload = any> {
-    filters: EventObserverFilter[];
-    priority: number;
-    /**
-     * If true, the observer will be executed asynchronously without blocking.
-     * The main flow will not wait for this observer to complete.
-     * @default false
-     */
-    fireAndForget?: boolean;
-    readonly apply?: (event: CreatedEvent<Payload>) => Promise<void> | void;
-}
-export declare enum SideEffectsState {
-    done = "SideEffects:done",
-    retry = "SideEffects:retry",
-    fail = "SideEffects:fail"
-}
-export declare enum EventOutputState {
-    success = "Event:success",
-    invalid = "Event:invalid",
-    canceled = "Event:canceled",
-    reverted = "Event:reverted",
-    revertFailed = "Event:revertFailed"
-}
-export declare enum EventObserverState {
-    success = "Observer:success"
-}
-/**
- * Use this type when defining new EventFlows.
- * The `kind` field enables TypeScript to narrow the type automatically.
- */
-export type TypedEventFlow<P = any, S = any> = (EventFlow<P, P> & {
-    readonly kind: 'simple';
-}) | (AggregateEventFlow<P, P, S> & {
-    readonly kind: 'aggregate';
-});
-export {};

package/dist/EventStore.types.js

@@ -1,21 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventObserverState = exports.EventOutputState = exports.SideEffectsState = void 0;
-var SideEffectsState;
-(function (SideEffectsState) {
-    SideEffectsState["done"] = "SideEffects:done";
-    SideEffectsState["retry"] = "SideEffects:retry";
-    SideEffectsState["fail"] = "SideEffects:fail";
-})(SideEffectsState = exports.SideEffectsState || (exports.SideEffectsState = {}));
-var EventOutputState;
-(function (EventOutputState) {
-    EventOutputState["success"] = "Event:success";
-    EventOutputState["invalid"] = "Event:invalid";
-    EventOutputState["canceled"] = "Event:canceled";
-    EventOutputState["reverted"] = "Event:reverted";
-    EventOutputState["revertFailed"] = "Event:revertFailed";
-})(EventOutputState = exports.EventOutputState || (exports.EventOutputState = {}));
-var EventObserverState;
-(function (EventObserverState) {
-    EventObserverState["success"] = "Observer:success";
-})(EventObserverState = exports.EventObserverState || (exports.EventObserverState = {}));

package/dist/Repo.types.d.ts

@@ -1,84 +1,36 @@
-import type { CreatedEvent } from './EventStore.types';
-export interface IEventStoreEntity<PAYLOAD = any, META = any> {
-    id: string;
-    domain: string;
-    type: string;
-    meta?: META;
-    payload: PAYLOAD;
-    identifier?: string;
-    correlationId?: string;
-    causationId?: string;
+import type { CreatedEvent, EventMeta } from './EventStore.types';
+export interface PersistedEvent<Payload = any, META extends EventMeta = EventMeta> extends CreatedEvent<Payload, META> {
     sequence?: number;
-    readonly created: Date;
-}
-export interface StoreEventsOptions {
-    /**
-     * Expected sequence number for the stream (domain + identifier).
-     * If provided, the store will verify the current sequence matches
-     * before writing. Throws ConcurrencyError on mismatch.
-     */
-    expectedSequence?: number;
 }
-export interface ISnapshotEntity<STATE = any> {
+export interface Snapshot<State = any> {
     domain: string;
     identifier: string;
-    state: STATE;
+    state: State;
     sequence: number;
     created: Date;
 }
-export interface IEventStoreRepoCapabilities {
-    /**
-     * Supports aggregate reconstruction through eventStore.getAggregate().
-     * Requires getStreamEvents(domain, identifier, fromSequence).
-     */
-    aggregate?: boolean;
+export interface EventStoreAdapter {
+    init(): Promise<void>;
+    close?(): Promise<void>;
+    append(events: PersistedEvent[]): Promise<void>;
+    getAllEvents(pageSize?: number, startFromId?: string): Promise<AsyncIterableIterator<Array<PersistedEvent>>>;
+    reset?(): Promise<void>;
+}
+export interface StreamEventStoreAdapter extends EventStoreAdapter {
+    getStreamEvents(domain: string, identifier: string, fromSequence?: number): Promise<PersistedEvent[]>;
+    appendToStream(events: PersistedEvent[], expectedVersion: number): Promise<{
+        nextVersion: number;
+    }>;
+    getSnapshot?<State>(domain: string, identifier: string): Promise<Snapshot<State> | null>;
+    saveSnapshot?<State>(snapshot: Snapshot<State>): Promise<void>;
+    capabilities: {
+        streamQuery: true;
+        optimisticConcurrency: true;
+        snapshot?: boolean;
+    };
 }
-export interface IEventStoreRepo<PAYLOAD = any, META = any> {
-    init: () => Promise<void>;
-    getAllEvents: (pageSize: number, startFromId?: string) => Promise<AsyncIterableIterator<Array<IEventStoreEntity<PAYLOAD, META>>>>;
-    createEventEntity: (event: CreatedEvent<any>) => IEventStoreEntity<PAYLOAD, META>;
-    storeEvents: (events: CreatedEvent<any>[], options?: StoreEventsOptions) => Promise<void>;
-    resetStore: () => Promise<void>;
-    /**
-     * Optional explicit capability declaration.
-     * If omitted, runtime infers support from implemented methods for backwards compatibility.
-     */
-    capabilities?: IEventStoreRepoCapabilities;
-    /**
-     * Get events for a specific stream (domain + identifier).
-     * MUST use efficient index-based query (e.g., DynamoDB Query, SQL WHERE).
-     * Required for getAggregate to work.
-     *
-     * @param domain - Event domain
-     * @param identifier - Stream identifier
-     * @param fromSequence - Start from this sequence (exclusive), 0 = from beginning
-     * @returns Events ordered by sequence ascending
-     */
-    getStreamEvents?: (domain: string, identifier: string, fromSequence?: number) => Promise<IEventStoreEntity<PAYLOAD, META>[]>;
-    getSnapshot?: <STATE>(domain: string, identifier: string) => Promise<ISnapshotEntity<STATE> | null>;
-    saveSnapshot?: <STATE>(snapshot: ISnapshotEntity<STATE>) => Promise<void>;
-    /**
-     * Get the current sequence number for a stream.
-     * Returns 0 if no events exist for this stream.
-     */
-    getStreamSequence?: (domain: string, identifier: string) => Promise<number>;
-    /**
-     * Retrieves a single event by its ID.
-     * Required for revert operations.
-     */
-    getEventById?: (id: string) => Promise<IEventStoreEntity<PAYLOAD, META> | null>;
-    /**
-     * Finds all events directly caused by the specified event.
-     * Returns events where causationId equals the given eventId.
-     * Required for revert operations to traverse the event tree.
-     *
-     * Note for DynamoDB: Consider adding a GSI on causationId for better
-     * performance. Without a GSI, this will result in a table scan.
-     */
-    findByCausationId?: (causationId: string) => Promise<IEventStoreEntity<PAYLOAD, META>[]>;
-    /**
-     * Closes the database connection and releases resources.
-     * Called during graceful shutdown.
-     */
-    close?: () => Promise<void>;
+export interface RevertableEventStoreAdapter {
+    getEventById(id: string): Promise<PersistedEvent | null>;
+    findByCausationId(causationId: string): Promise<PersistedEvent[]>;
+    append(events: PersistedEvent[]): Promise<void>;
 }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export * from './EventStore.types';
 export * from './Repo.types';
-export * from './Revert.types';
 export * from './Errors';

package/dist/index.js

@@ -16,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./EventStore.types"), exports);
 __exportStar(require("./Repo.types"), exports);
-__exportStar(require("./Revert.types"), exports);
 __exportStar(require("./Errors"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schemeless/event-store-types",
-  "version": "5.0.0",
+  "version": "6.0.0-rc.1",
   "typescript:main": "src/index.ts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,5 +34,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b391c1569bd4416b1aca13037d1a20a4d5899f25"
+  "gitHead": "4f7e7204918ac13e2387d546ea4f6d347e83f7a8"
 }

package/readme.md

@@ -1,95 +1,37 @@
 # @schemeless/event-store-types
 
-Shared TypeScript definitions used by the event store runtime, adapters, and application code. Import these contracts when authoring event flows, observers, or custom persistence layers.
+Shared TypeScript contracts for the V6 architecture.
 
-## Installation
-
-```bash
-yarn add @schemeless/event-store-types
-```
-
-## Event primitives
-
-The package defines the shape of event inputs, created events, and the lifecycle metadata that flows through the runtime.
-
-```ts
-import { BaseEventInput, CreatedEvent, EventFlow } from '@schemeless/event-store-types';
-
-const draft: BaseEventInput<{ id: string }> = {
-  payload: { id: '123' },
-};
-
-const eventFlow: EventFlow = {
-  domain: 'user',
-  type: 'registered',
-  receive: (eventStore) => eventStore.receive(eventFlow),
-};
-```
-
-`CreatedEvent` extends the base shape with generated identifiers and timestamps, while `SideEffectsState`, `EventOutputState`, and `EventObserverState` describe the possible outcomes emitted by the runtime.
-
-### Traceability IDs
-
-The event store uses several ID fields to track causation and correlation across event chains:
+Primary consumers:
 
-- **`correlationId`** – Groups all events originating from the same root command. The framework inherits this from parent events or creates it for root events. Developers can optionally pass this from external systems (e.g., HTTP request headers).
-- **`causationId`** – Links each event to its immediate parent. This field is **managed exclusively by the framework** via `createConsequentEvents` or `sideEffect` handlers.
-- **`identifier`** – Developer-provided field to record who or what triggered the event (e.g., user ID, service name).
-- **`trackingId`** – Developer-provided external reference for cross-system tracing.
+- `@schemeless/event-store-core`
+- `@schemeless/event-store-aggregate`
+- adapter packages
 
-> **Important:** Do not manually set `causationId` in your event inputs. The framework automatically populates this field based on the event creation context to ensure chain integrity.
+This package is the canonical home for:
 
-## Repository contracts
+- persisted event types
+- snapshot types
+- adapter capability contracts
+- concurrency and snapshot errors
 
-`Repo.types` exposes the `IEventStoreRepo` and `IEventStoreEntity` interfaces. Adapters implement these to integrate with the core runtime.
-
-```ts
-import { IEventStoreRepo } from '@schemeless/event-store-types';
+## Installation
 
-class CustomRepo implements IEventStoreRepo {
-  async init() {}
-  async getAllEvents(pageSize: number) {
-    // return an async iterator of stored events
-  }
-  createEventEntity(event) {
-    return event;
-  }
-  async storeEvents(events) {}
-  async resetStore() {}
-}
+```bash
+yarn add @schemeless/event-store-types
 ```
 
-The iterator returned by `getAllEvents` yields arrays of `IEventStoreEntity` records. Each record includes identifiers, correlation/causation metadata, and the `created` timestamp so replays can process history in order.
-
-### Revert support
-
-To enable revert operations, adapters should also implement two additional optional methods:
+## Main contracts
 
 ```ts
-class CustomRepo implements IEventStoreRepo {
-  // ... existing methods ...
-
-  async getEventById(id: string) {
-    // Return a single event by ID, or null if not found
-  }
-
-  async findByCausationId(causationId: string) {
-    // Return all events where causationId equals the given value
-    // Used to traverse the event tree during reverts
-  }
-}
+import type {
+  PersistedEvent,
+  Snapshot,
+  EventStoreAdapter,
+  StreamEventStoreAdapter,
+} from '@schemeless/event-store-types';
 ```
 
-> **Note:** For DynamoDB adapters, consider adding a Global Secondary Index on `causationId` for better performance.
-
-## Revert types
-
-The package exports types for the revert API:
-
-```ts
-import { CanRevertResult, PreviewRevertResult, RevertResult } from '@schemeless/event-store-types';
-```
+## Design note
 
-- `CanRevertResult` – Indicates whether an event can be reverted, with reasons if not
-- `PreviewRevertResult` – Shows which events would be affected by a revert
-- `RevertResult` – Contains the outcome of a revert operation, including generated compensating events
+New code should target the V6 split architecture. This package only carries shared contracts and storage-facing types.

package/dist/Revert.types.d.ts

@@ -1,38 +0,0 @@
-import type { CreatedEvent } from './EventStore.types';
-/**
- * Result of canRevert() check
- */
-export interface CanRevertResult {
-    /** Whether the event can be reverted */
-    canRevert: boolean;
-    /** Reason why revert is not possible (if canRevert is false) */
-    reason?: string;
-    /** Events missing the 'compensate' hook */
-    missingCompensateEvents?: Array<{
-        id: string;
-        domain: string;
-        type: string;
-    }>;
-}
-/**
- * Result of previewRevert() - shows what would be affected
- */
-export interface PreviewRevertResult {
-    /** The root event that would be reverted */
-    rootEvent: CreatedEvent<any>;
-    /** All descendant events that would be reverted */
-    descendantEvents: CreatedEvent<any>[];
-    /** Total count of events affected */
-    totalEventCount: number;
-}
-/**
- * Result of a successful revert() operation
- */
-export interface RevertResult {
-    /** ID of the event that was reverted */
-    revertedEventId: string;
-    /** Compensating events generated for this event */
-    compensatingEvents: CreatedEvent<any>[];
-    /** Revert results for child events */
-    childResults: RevertResult[];
-}

package/dist/Revert.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });