@opencode-ai/schema 0.0.0-next-14723 → 0.0.0-next-14730

package/dist/event-log.d.ts

@@ -0,0 +1,46 @@
+export * as EventLog from "./event-log.js";
+import { Schema } from "effect";
+/**
+ * Replay-to-live boundary marker for a durable log read. The reader now holds
+ * every event committed at or below `seq`; `seq` is absent when the log holds
+ * no events at or before the read position. May be re-emitted after the
+ * reader internally re-attaches.
+ */
+export declare const CaughtUp: Schema.Struct<{
+    readonly type: Schema.Literal<"log.caught_up">;
+    readonly aggregateID: Schema.String;
+    readonly seq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Int, "Event.Seq">>>, Schema.optionalKey<Schema.brand<Schema.Int, "Event.Seq">>, never, never>;
+}>;
+export interface CaughtUp extends Schema.Schema.Type<typeof CaughtUp> {
+}
+/**
+ * A payload-free doorbell: the aggregate's log advanced to at least `seq`.
+ * Hints are a latency optimization only; no consumer may derive correctness
+ * from receiving one. Correctness always comes from a durable log read plus
+ * the consumer's own checkpoint.
+ */
+export declare const Hint: Schema.Struct<{
+    readonly type: Schema.Literal<"log.hint">;
+    readonly aggregateID: Schema.String;
+    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+}>;
+export interface Hint extends Schema.Schema.Type<typeof Hint> {
+}
+/**
+ * Hints may have been lost. Treat every aggregate as potentially dirty and
+ * recover via bounded sweep plus durable log reads. Also emitted first on
+ * every (re)subscribe, since hints during disconnection were never buffered.
+ */
+export declare const SweepRequired: Schema.Struct<{
+    readonly type: Schema.Literal<"log.sweep_required">;
+}>;
+export interface SweepRequired extends Schema.Schema.Type<typeof SweepRequired> {
+}
+export declare const Change: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"log.hint">;
+    readonly aggregateID: Schema.String;
+    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"log.sweep_required">;
+}>]>;
+export type Change = typeof Change.Type;

package/dist/event-log.js

@@ -0,0 +1,44 @@
+export * as EventLog from "./event-log.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+import { optional } from "./schema.js";
+/**
+ * Replay-to-live boundary marker for a durable log read. The reader now holds
+ * every event committed at or below `seq`; `seq` is absent when the log holds
+ * no events at or before the read position. May be re-emitted after the
+ * reader internally re-attaches.
+ */
+export const CaughtUp = Schema.Struct({
+    type: Schema.Literal("log.caught_up"),
+    aggregateID: Schema.String,
+    seq: optional(Event.Seq),
+}).annotate({
+    identifier: "EventLog.CaughtUp",
+    description: "Marker emitted when a log read transitions from replay to live (or completes a finite read). The reader holds every event committed at or below seq.",
+});
+/**
+ * A payload-free doorbell: the aggregate's log advanced to at least `seq`.
+ * Hints are a latency optimization only; no consumer may derive correctness
+ * from receiving one. Correctness always comes from a durable log read plus
+ * the consumer's own checkpoint.
+ */
+export const Hint = Schema.Struct({
+    type: Schema.Literal("log.hint"),
+    aggregateID: Schema.String,
+    seq: Event.Seq,
+}).annotate({
+    identifier: "EventLog.Hint",
+    description: "Payload-free change hint: the aggregate's durable log advanced to at least seq. Hints coalesce under backpressure (latest per aggregate) and are never a delivery guarantee.",
+});
+/**
+ * Hints may have been lost. Treat every aggregate as potentially dirty and
+ * recover via bounded sweep plus durable log reads. Also emitted first on
+ * every (re)subscribe, since hints during disconnection were never buffered.
+ */
+export const SweepRequired = Schema.Struct({
+    type: Schema.Literal("log.sweep_required"),
+}).annotate({
+    identifier: "EventLog.SweepRequired",
+    description: "Hints may have been lost; treat every aggregate as potentially dirty and recover via bounded sweep plus durable log reads. Emitted first on every (re)subscribe.",
+});
+export const Change = Schema.Union([Hint, SweepRequired]).annotate({ identifier: "EventLog.Change" });