@house-rules/event-log 0.0.0-stage → 0.1.0

package/dist/event/event-log.d.ts

@@ -0,0 +1,136 @@
+import { Effect, Schema } from "effect";
+import type { EventStore } from "../storage.js";
+import { DeadLetterNotFound, EventInputInvalid, EventStoreUnavailable } from "./event.js";
+import type { EventLogSettings } from "./options.js";
+declare const ClaimQuery: Schema.Struct<{
+    readonly consumer: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export type ClaimQuery = typeof ClaimQuery.Type;
+export declare const makeEventLog: (store: EventStore["Service"], options: EventLogSettings) => {
+    consumers: () => Effect.Effect<{
+        name: string;
+        kinds: string[];
+    }[], never, never>;
+    record: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    } | null, fact: {
+        readonly kind: string;
+        readonly subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly payload: unknown;
+        readonly scopeId: string | null;
+    }, requestId?: string | null | undefined) => Effect.Effect<{
+        kind: string;
+        subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        scopeId: string | null;
+        id: string;
+        actorId: string | null;
+        occurredAt: number;
+        requestId: string | null;
+        payload: unknown;
+    }, EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    read: (query?: {
+        readonly after?: string;
+        readonly kinds?: readonly string[];
+        readonly subject?: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        readonly scopeId?: string;
+        readonly requestId?: string;
+        readonly from?: number;
+        readonly to?: number;
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<{
+        kind: string;
+        subject: {
+            readonly kind: string;
+            readonly id: string;
+        };
+        scopeId: string | null;
+        id: string;
+        actorId: string | null;
+        occurredAt: number;
+        requestId: string | null;
+        payload: unknown;
+    }[], EventInputInvalid | EventStoreUnavailable, never>;
+    due: () => Effect.Effect<{
+        consumer: string;
+    }[], EventStoreUnavailable, never>;
+    claimDue: (query?: {
+        readonly consumer?: string;
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<{
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }[], EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    takeNext: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }) => Effect.Effect<{
+        event: {
+            kind: string;
+            subject: {
+                readonly kind: string;
+                readonly id: string;
+            };
+            scopeId: string | null;
+            id: string;
+            actorId: string | null;
+            occurredAt: number;
+            requestId: string | null;
+            payload: unknown;
+        };
+        token: {
+            readonly consumer: string;
+            readonly eventId: string;
+            readonly attempt: number;
+            readonly replay: boolean;
+            readonly generation: string;
+        };
+    } | null, EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    settleSuccess: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }) => Effect.Effect<boolean, EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    settleFailure: (token: {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly attempt: number;
+        readonly replay: boolean;
+        readonly generation: string;
+    }, lastError: string) => Effect.Effect<boolean, EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    listDeadLetters: (query?: {
+        readonly consumer?: string;
+        readonly after?: {
+            readonly eventId: string;
+            readonly consumer: string;
+        };
+        readonly limit?: number;
+    } | undefined) => Effect.Effect<readonly {
+        readonly consumer: string;
+        readonly eventId: string;
+        readonly lastError: string;
+        readonly attempts: number;
+        readonly failedAt: number;
+    }[], EventInputInvalid | EventStoreUnavailable, never>;
+    replay: (consumer: string, eventId: string) => Effect.Effect<"already_queued" | "busy" | "enqueued", DeadLetterNotFound | EventInputInvalid | EventStoreUnavailable | import("@house-rules/domain").NoOpenUnit, never>;
+    wakeups: () => Effect.Effect<import("effect/Stream").Stream<void, EventStoreUnavailable, never>, never, never>;
+};
+export type EventLogService = ReturnType<typeof makeEventLog>;
+export {};

package/dist/event/event-log.js

@@ -0,0 +1,172 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { DateTime, Effect, Random, Schema } from "effect";
+import { DeadLetterQuery, DeliveryToken } from "./delivery.js";
+import { DeadLetterNotFound, EventFact, EventId, EventInputInvalid, EventQuery, EventStoreUnavailable, } from "./event.js";
+const invalid = () => new EventInputInvalid({ message: "Invalid event log input." });
+const now = DateTime.now.pipe(Effect.map(DateTime.toEpochMillis));
+const ClaimQuery = Schema.Struct({
+    consumer: Schema.optionalKey(Schema.NonEmptyString),
+    limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))),
+});
+export const makeEventLog = (store, options) => {
+    const registration = (name) => {
+        const consumer = options.consumers.find((entry) => entry.name === name);
+        return consumer === undefined ? Effect.fail(invalid()) : Effect.succeed(consumer);
+    };
+    const decodePayload = Effect.fn("EventLog.decodePayload")(function* (fact) {
+        const schema = Object.hasOwn(options.registry, fact.kind)
+            ? options.registry[fact.kind]
+            : undefined;
+        if (schema === undefined)
+            return yield* invalid();
+        return yield* Schema.decodeUnknownEffect(schema)(fact.payload).pipe(Effect.mapError(invalid));
+    });
+    const lockedCandidate = Effect.fn("EventLog.lockedCandidate")(function* (consumer) {
+        yield* UnitOfWork.required;
+        const config = yield* registration(consumer);
+        if (!(yield* store.lock(consumer)))
+            return undefined;
+        return yield* store.candidate(consumer, config.kinds);
+    });
+    const matching = Effect.fn("EventLog.matching")(function* (token) {
+        yield* Schema.decodeEffect(DeliveryToken)(token).pipe(Effect.mapError(invalid));
+        const candidate = yield* lockedCandidate(token.consumer);
+        return candidate !== undefined &&
+            candidate.event.id === token.eventId &&
+            candidate.attempts === token.attempt &&
+            candidate.replay === token.replay &&
+            candidate.generation === token.generation
+            ? candidate
+            : undefined;
+    });
+    return {
+        consumers: () => Effect.succeed(options.consumers.map(({ name, kinds }) => ({ name, kinds }))),
+        record: Effect.fn("EventLog.record")(function* (actor, fact, requestId = null) {
+            yield* UnitOfWork.required;
+            const decoded = yield* Schema.decodeEffect(EventFact)(fact).pipe(Effect.mapError(invalid));
+            const payload = yield* decodePayload(decoded);
+            const schema = options.registry[decoded.kind];
+            if (schema === undefined)
+                return yield* invalid();
+            const encoded = yield* Schema.encodeUnknownEffect(schema)(payload).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.Json)), Effect.mapError(invalid));
+            const stored = yield* store.append({
+                ...decoded,
+                payload: encoded,
+                actorId: actor?.id ?? null,
+                occurredAt: yield* now,
+                requestId,
+            });
+            return { ...stored, payload };
+        }),
+        read: Effect.fn("EventLog.read")(function* (query = {}) {
+            const decoded = yield* Schema.decodeEffect(EventQuery)(query).pipe(Effect.mapError(invalid));
+            const events = yield* store.read(decoded);
+            return yield* Effect.forEach(events, (event) => decodePayload(event).pipe(Effect.map((payload) => ({ ...event, payload })), Effect.mapError((cause) => new EventStoreUnavailable({ cause }))));
+        }),
+        due: Effect.fn("EventLog.due")(function* () {
+            const at = yield* now;
+            const due = [];
+            for (const consumer of options.consumers) {
+                const next = yield* store.candidate(consumer.name, consumer.kinds);
+                if (next !== undefined && next.nextDue <= at)
+                    due.push({ consumer: consumer.name });
+            }
+            return due;
+        }),
+        claimDue: Effect.fn("EventLog.claimDue")(function* (query = {}) {
+            yield* UnitOfWork.required;
+            yield* Schema.decodeEffect(ClaimQuery)(query).pipe(Effect.mapError(invalid));
+            if (query.consumer !== undefined)
+                yield* registration(query.consumer);
+            const tokens = [];
+            const at = yield* now;
+            for (const consumer of options.consumers) {
+                if (query.consumer !== undefined && consumer.name !== query.consumer)
+                    continue;
+                if (tokens.length >= (query.limit ?? 100))
+                    break;
+                const candidate = yield* lockedCandidate(consumer.name);
+                if (candidate === undefined || candidate.nextDue > at)
+                    continue;
+                if (candidate.attempts >= consumer.maxAttempts) {
+                    yield* store.deadLetter({
+                        consumer: consumer.name,
+                        eventId: candidate.event.id,
+                        lastError: candidate.lastError,
+                        attempts: candidate.attempts,
+                        failedAt: at,
+                    });
+                    yield* store.advance(consumer.name, candidate.event.id, candidate.replay);
+                    continue;
+                }
+                const attempt = candidate.attempts + 1;
+                const delay = Math.min(consumer.backoff.baseMs * 2 ** (attempt - 1), consumer.backoff.capMs);
+                yield* store.retry(consumer.name, { ...candidate, attempts: attempt, nextDue: at + delay });
+                tokens.push({
+                    consumer: consumer.name,
+                    eventId: candidate.event.id,
+                    attempt,
+                    replay: candidate.replay,
+                    generation: candidate.generation,
+                });
+            }
+            return tokens;
+        }),
+        takeNext: Effect.fn("EventLog.takeNext")(function* (token) {
+            const candidate = yield* matching(token);
+            if (candidate === undefined)
+                return null;
+            return {
+                event: { ...candidate.event, payload: yield* decodePayload(candidate.event) },
+                token,
+            };
+        }),
+        settleSuccess: Effect.fn("EventLog.settleSuccess")(function* (token) {
+            const candidate = yield* matching(token);
+            if (candidate === undefined)
+                return false;
+            yield* store.advance(token.consumer, token.eventId, token.replay);
+            if (token.replay)
+                yield* store.clearDeadLetter(token.consumer, token.eventId);
+            return true;
+        }),
+        settleFailure: Effect.fn("EventLog.settleFailure")(function* (token, lastError) {
+            const candidate = yield* matching(token);
+            if (candidate === undefined)
+                return false;
+            yield* store.retry(token.consumer, { ...candidate, lastError });
+            return true;
+        }),
+        listDeadLetters: Effect.fn("EventLog.listDeadLetters")(function* (query = {}) {
+            const decoded = yield* Schema.decodeEffect(DeadLetterQuery)(query).pipe(Effect.mapError(invalid));
+            return yield* store.listDeadLetters(decoded);
+        }),
+        replay: Effect.fn("EventLog.replay")(function* (consumer, eventId) {
+            yield* UnitOfWork.required;
+            const config = yield* registration(consumer);
+            yield* Schema.decodeEffect(EventId)(eventId).pipe(Effect.mapError(invalid));
+            if (!(yield* store.lock(consumer)))
+                return "busy";
+            const dead = yield* store.findDeadLetter(consumer, eventId);
+            if (dead === undefined)
+                return yield* new DeadLetterNotFound();
+            const [event] = yield* store.read({
+                ...(BigInt(eventId) > 1n ? { after: (BigInt(eventId) - 1n).toString() } : {}),
+                limit: 1,
+            });
+            if (event === undefined || event.id !== eventId || !config.kinds.includes(event.kind))
+                return yield* invalid();
+            const generation = yield* Effect.all(Array.from({ length: 4 }, () => Random.nextIntBetween(0, 0xffff_ffff))).pipe(Effect.map((words) => words.map((word) => word.toString(16).padStart(8, "0")).join("")));
+            const enqueued = yield* store.enqueueReplay(consumer, {
+                event,
+                attempts: 0,
+                nextDue: 0,
+                replay: true,
+                generation,
+                lastError: "Delivery failed. See internal logs.",
+            });
+            return (enqueued ? "enqueued" : "already_queued");
+        }),
+        wakeups: () => Effect.succeed(store.wakeups),
+    };
+};

package/dist/event/event.d.ts

@@ -0,0 +1,60 @@
+import { Schema } from "effect";
+export declare const EventId: Schema.String;
+export declare const EventFact: Schema.Struct<{
+    readonly kind: Schema.NonEmptyString;
+    readonly subject: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly payload: Schema.Unknown;
+    readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+export type EventFact = typeof EventFact.Type;
+export declare const StoredEvent: Schema.Struct<{
+    readonly kind: Schema.NonEmptyString;
+    readonly subject: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly payload: Schema.Unknown;
+    readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+    readonly id: Schema.String;
+    readonly actorId: Schema.NullOr<Schema.NonEmptyString>;
+    readonly occurredAt: Schema.Int;
+    readonly requestId: Schema.NullOr<Schema.String>;
+}>;
+export type StoredEvent = typeof StoredEvent.Type;
+export declare const EventQuery: Schema.Struct<{
+    readonly after: Schema.optionalKey<Schema.String>;
+    readonly kinds: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly subject: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+    readonly scopeId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly requestId: Schema.optionalKey<Schema.String>;
+    readonly from: Schema.optionalKey<Schema.Int>;
+    readonly to: Schema.optionalKey<Schema.Int>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export type EventQuery = typeof EventQuery.Type;
+declare const EventInputInvalid_base: Schema.Class<EventInputInvalid, Schema.TaggedStruct<"EventInputInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventInputInvalid extends EventInputInvalid_base {
+}
+declare const EventStoreUnavailable_base: Schema.Class<EventStoreUnavailable, Schema.TaggedStruct<"EventStoreUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventStoreUnavailable extends EventStoreUnavailable_base {
+    get message(): string;
+}
+declare const DeadLetterNotFound_base: Schema.Class<DeadLetterNotFound, Schema.TaggedStruct<"DeadLetterNotFound", {
+    readonly kind: Schema.tag<"not_found">;
+}>, import("effect/Cause").YieldableError>;
+export declare class DeadLetterNotFound extends DeadLetterNotFound_base {
+    get message(): string;
+}
+export {};

package/dist/event/event.js

@@ -0,0 +1,46 @@
+import { errorKind } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+export const EventId = Schema.String.check(Schema.isPattern(/^[1-9][0-9]*$/), Schema.isMaxLength(19), Schema.makeFilter((id) => id.length < 19 || id <= "9223372036854775807"));
+export const EventFact = Schema.Struct({
+    kind: Schema.NonEmptyString,
+    subject: Schema.Struct({ kind: Schema.NonEmptyString, id: Schema.NonEmptyString }),
+    payload: Schema.Unknown,
+    scopeId: Schema.NullOr(Schema.NonEmptyString),
+});
+export const StoredEvent = Schema.Struct({
+    ...EventFact.fields,
+    id: EventId,
+    actorId: Schema.NullOr(Schema.NonEmptyString),
+    occurredAt: Schema.Int,
+    requestId: Schema.NullOr(Schema.String),
+});
+export const EventQuery = Schema.Struct({
+    after: Schema.optionalKey(EventId),
+    kinds: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+    subject: Schema.optionalKey(EventFact.fields.subject),
+    scopeId: Schema.optionalKey(Schema.NonEmptyString),
+    requestId: Schema.optionalKey(Schema.String),
+    from: Schema.optionalKey(Schema.Int),
+    to: Schema.optionalKey(Schema.Int),
+    limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))),
+});
+export class EventInputInvalid extends Schema.TaggedError()("EventInputInvalid", {
+    kind: errorKind("invalid"),
+    message: Schema.String,
+}) {
+}
+export class EventStoreUnavailable extends Schema.TaggedError()("EventStoreUnavailable", {
+    kind: errorKind("unavailable"),
+    cause: Schema.Defect(),
+}) {
+    get message() {
+        return "Event log is unavailable. Try again shortly.";
+    }
+}
+export class DeadLetterNotFound extends Schema.TaggedError()("DeadLetterNotFound", {
+    kind: errorKind("not_found"),
+}) {
+    get message() {
+        return "Dead letter not found.";
+    }
+}

package/dist/event/operations.d.ts

@@ -0,0 +1,126 @@
+import { Schema } from "effect";
+import { DeadLetterNotFound, EventInputInvalid, EventStoreUnavailable } from "./event.js";
+export declare const EventLogOperations: {
+    readonly record: import("@house-rules/domain/contract").Operation<"EventLog.record", Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly subject: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly payload: Schema.Unknown;
+        readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly subject: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly payload: Schema.Unknown;
+        readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly id: Schema.String;
+        readonly actorId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly occurredAt: Schema.Int;
+        readonly requestId: Schema.NullOr<Schema.String>;
+    }>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly read: import("@house-rules/domain/contract").Operation<"EventLog.read", Schema.Struct<{
+        readonly after: Schema.optionalKey<Schema.String>;
+        readonly kinds: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly subject: Schema.optionalKey<Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>>;
+        readonly scopeId: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly requestId: Schema.optionalKey<Schema.String>;
+        readonly from: Schema.optionalKey<Schema.Int>;
+        readonly to: Schema.optionalKey<Schema.Int>;
+        readonly limit: Schema.optionalKey<Schema.Int>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly subject: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly payload: Schema.Unknown;
+        readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly id: Schema.String;
+        readonly actorId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly occurredAt: Schema.Int;
+        readonly requestId: Schema.NullOr<Schema.String>;
+    }>>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly due: import("@house-rules/domain/contract").Operation<"EventLog.due", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+    }>>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly claimDue: import("@house-rules/domain/contract").Operation<"EventLog.claimDue", Schema.Struct<{
+        readonly consumer: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly limit: Schema.optionalKey<Schema.Int>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+        readonly eventId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly replay: Schema.Boolean;
+        readonly generation: Schema.String;
+    }>>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly takeNext: import("@house-rules/domain/contract").Operation<"EventLog.takeNext", Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+        readonly eventId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly replay: Schema.Boolean;
+        readonly generation: Schema.String;
+    }>, Schema.NullOr<Schema.Struct<{
+        readonly token: Schema.Struct<{
+            readonly consumer: Schema.NonEmptyString;
+            readonly eventId: Schema.String;
+            readonly attempt: Schema.Int;
+            readonly replay: Schema.Boolean;
+            readonly generation: Schema.String;
+        }>;
+        readonly event: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly subject: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly payload: Schema.Unknown;
+            readonly scopeId: Schema.NullOr<Schema.NonEmptyString>;
+            readonly id: Schema.String;
+            readonly actorId: Schema.NullOr<Schema.NonEmptyString>;
+            readonly occurredAt: Schema.Int;
+            readonly requestId: Schema.NullOr<Schema.String>;
+        }>;
+    }>>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly settleSuccess: import("@house-rules/domain/contract").Operation<"EventLog.settleSuccess", Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+        readonly eventId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly replay: Schema.Boolean;
+        readonly generation: Schema.String;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly settleFailure: import("@house-rules/domain/contract").Operation<"EventLog.settleFailure", Schema.Struct<{
+        readonly token: Schema.Struct<{
+            readonly consumer: Schema.NonEmptyString;
+            readonly eventId: Schema.String;
+            readonly attempt: Schema.Int;
+            readonly replay: Schema.Boolean;
+            readonly generation: Schema.String;
+        }>;
+        readonly lastError: Schema.String;
+    }>, Schema.Boolean, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false>;
+    readonly listDeadLetters: import("@house-rules/domain/contract").Operation<"EventLog.listDeadLetters", Schema.Struct<{
+        readonly consumer: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly after: Schema.optionalKey<Schema.Struct<{
+            readonly eventId: Schema.String;
+            readonly consumer: Schema.NonEmptyString;
+        }>>;
+        readonly limit: Schema.optionalKey<Schema.Int>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+        readonly eventId: Schema.String;
+        readonly lastError: Schema.String;
+        readonly attempts: Schema.Int;
+        readonly failedAt: Schema.Int;
+    }>>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>;
+    readonly replay: import("@house-rules/domain/contract").Operation<"EventLog.replay", Schema.Struct<{
+        readonly consumer: Schema.NonEmptyString;
+        readonly eventId: Schema.String;
+    }>, Schema.Literals<readonly ["enqueued", "busy", "already_queued"]>, Schema.Union<readonly [typeof EventInputInvalid, typeof EventStoreUnavailable, typeof DeadLetterNotFound]>, NoInfer<readonly []>, false, false, true, true>;
+};

package/dist/event/operations.js

@@ -0,0 +1,94 @@
+import { defineOperation } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+import { DeadLetter, DeadLetterQuery, Delivery, DeliveryToken, ReplayResult } from "./delivery.js";
+import { DeadLetterNotFound, EventFact, EventInputInvalid, EventQuery, EventStoreUnavailable, StoredEvent, } from "./event.js";
+import { EventLogPermissions } from "./permissions.js";
+const failure = Schema.Union([EventInputInvalid, EventStoreUnavailable]);
+const consumer = Schema.Struct({ consumer: Schema.NonEmptyString });
+const record = defineOperation("EventLog.record", {
+    description: "Validate a domain fact and append its envelope to the transactional outbox.",
+    input: EventFact,
+    output: StoredEvent,
+    failure,
+    permission: EventLogPermissions.record,
+    transactional: true,
+});
+const read = defineOperation("EventLog.read", {
+    description: "Read event history in global cursor order.",
+    input: EventQuery,
+    output: Schema.Array(StoredEvent),
+    failure,
+    permission: EventLogPermissions.read,
+    readOnly: true,
+});
+const due = defineOperation("EventLog.due", {
+    description: "Select consumers whose next delivery is due. Results are hints, not claims.",
+    input: Schema.Struct({}),
+    output: Schema.Array(consumer),
+    failure,
+    permission: EventLogPermissions.deliver,
+    readOnly: true,
+});
+const claimDue = defineOperation("EventLog.claimDue", {
+    description: "Commit delivery attempts and exponential retry times in the selector unit before running handler items.",
+    input: Schema.Struct({
+        consumer: Schema.optionalKey(Schema.NonEmptyString),
+        limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 1000 }))),
+    }),
+    output: Schema.Array(DeliveryToken),
+    failure,
+    permission: EventLogPermissions.deliver,
+    transactional: true,
+});
+const takeNext = defineOperation("EventLog.takeNext", {
+    description: "Lock a consumer until this handler unit ends. Ignore stale claimed attempts.",
+    input: DeliveryToken,
+    output: Schema.NullOr(Delivery),
+    failure,
+    permission: EventLogPermissions.deliver,
+    transactional: true,
+});
+const settleSuccess = defineOperation("EventLog.settleSuccess", {
+    description: "Advance a delivery cursor in the successful handler's unit.",
+    input: DeliveryToken,
+    output: Schema.Boolean,
+    failure,
+    permission: EventLogPermissions.deliver,
+    transactional: true,
+});
+const settleFailure = defineOperation("EventLog.settleFailure", {
+    description: "Optionally attach a safe failure summary in a fresh unit after handler rollback. Attempts and backoff already committed at claim.",
+    input: Schema.Struct({ token: DeliveryToken, lastError: Schema.String }),
+    output: Schema.Boolean,
+    failure,
+    permission: EventLogPermissions.deliver,
+    transactional: true,
+});
+const listDeadLetters = defineOperation("EventLog.listDeadLetters", {
+    description: "List dead letters per consumer, ordered by event cursor and consumer name.",
+    input: DeadLetterQuery,
+    output: Schema.Array(DeadLetter),
+    failure,
+    permission: EventLogPermissions.deadLetters,
+    readOnly: true,
+});
+const replay = defineOperation("EventLog.replay", {
+    description: "Manually enqueue one dead letter without rewinding the consumer cursor.",
+    input: Schema.Struct({ consumer: Schema.NonEmptyString, eventId: DeliveryToken.fields.eventId }),
+    output: ReplayResult,
+    failure: Schema.Union([EventInputInvalid, EventStoreUnavailable, DeadLetterNotFound]),
+    permission: EventLogPermissions.replay,
+    transactional: true,
+    needsApproval: true,
+});
+export const EventLogOperations = {
+    record,
+    read,
+    due,
+    claimDue,
+    takeNext,
+    settleSuccess,
+    settleFailure,
+    listDeadLetters,
+    replay,
+};

package/dist/event/options.d.ts

@@ -0,0 +1,33 @@
+import type { PlainSchema } from "@house-rules/domain/contract";
+import { ConsumerOptions } from "./delivery.js";
+import { Effect } from "effect";
+import { EventInputInvalid } from "./event.js";
+export type EventLogOptions = Readonly<{
+    registry: Readonly<Record<string, PlainSchema>>;
+    consumers: ReadonlyArray<ConsumerOptions>;
+}>;
+export declare const deliveryDefaults: {
+    readonly maxAttempts: 5;
+    readonly backoff: {
+        readonly baseMs: 1000;
+        readonly capMs: 300000;
+    };
+};
+export declare const validateOptions: (options: Readonly<{
+    registry: Readonly<Record<string, PlainSchema>>;
+    consumers: ReadonlyArray<ConsumerOptions>;
+}>) => Effect.Effect<{
+    registry: {
+        [x: string]: PlainSchema;
+    };
+    consumers: {
+        name: string;
+        kinds: string[];
+        maxAttempts: number;
+        backoff: {
+            readonly baseMs: number;
+            readonly capMs: number;
+        };
+    }[];
+}, EventInputInvalid, never>;
+export type EventLogSettings = Effect.Success<ReturnType<typeof validateOptions>>;