@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-fjb24bmd.js → event-logger-jbmjz4v3.js}

@@ -1,32 +1,32 @@
 import {
-  EventSequenceTable,
-  EventTable
-} from "./schema-zsf8rs93.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_keyed_mutex
-} from "./schema-66mds5ht.js";
+  EventSequenceTable2,
+  EventTable2
+} from "./event-logger-2710q6r3.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  makeUnsafe2
+} from "./event-logger-y71avatq.js";
 import {
-  __export,
-  __require
-} from "./schema-vpjkya7h.js";
+  __export
+} from "./event-logger-9rqn6x4v.js";
 
 // src/bus.ts
 var exports_bus = {};
 __export(exports_bus, {
   Bus: () => exports_bus,
-  InvalidDurableEventError: () => InvalidDurableEventError,
-  Service: () => Service,
-  configured: () => configured,
-  durable: () => durable,
-  ephemeral: () => ephemeral,
-  isSynced: () => isSynced,
-  latestSequence: () => latestSequence,
-  node: () => node,
-  reserveSequence: () => reserveSequence,
-  versionedType: () => versionedType
+  InvalidDurableEventError: () => InvalidDurableEventError2,
+  Service: () => Service79,
+  configured: () => configured12,
+  durable: () => durable2,
+  ephemeral: () => ephemeral2,
+  isSynced: () => isSynced2,
+  latestSequence: () => latestSequence2,
+  node: () => node84,
+  reserveSequence: () => reserveSequence2,
+  versionedType: () => versionedType2
 });
 import { Cause, Clock, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect";
 import { Event } from "@opencode-ai/schema/event";
@@ -36,18 +36,18 @@ import { isDeepStrictEqual } from "node:util";
 import { Durable } from "@opencode-ai/schema/durable-event-manifest";
 import { SessionEvent } from "@opencode-ai/schema/session-event";
 import { AbsolutePath } from "@opencode-ai/schema/schema";
-var latestSequence = Effect.fn("Bus.latestSequence")(function* (db, aggregateID) {
-  const row = yield* db.select({ seq: EventSequenceTable.seq }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+var latestSequence2 = Effect.fn("Bus.latestSequence")(function* (db, aggregateID) {
+  const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
   return row?.seq ?? -1;
 });
-var reserveSequence = Effect.fn("Bus.reserveSequence")(function* (db, aggregateID, seq) {
-  yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq }]).onConflictDoUpdate({
-    target: EventSequenceTable.aggregate_id,
-    set: { seq: sql`max(${EventSequenceTable.seq}, ${seq})` }
+var reserveSequence2 = Effect.fn("Bus.reserveSequence")(function* (db, aggregateID, seq) {
+  yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq }]).onConflictDoUpdate({
+    target: EventSequenceTable2.aggregate_id,
+    set: { seq: sql`max(${EventSequenceTable2.seq}, ${seq})` }
   }).run().pipe(Effect.orDie);
 });
 
-class InvalidDurableEventError extends Schema.TaggedError()("Bus.InvalidDurableEvent", {
+class InvalidDurableEventError2 extends Schema.TaggedError()("Bus.InvalidDurableEvent", {
   type: Schema.String,
   message: Schema.String
 }) {
@@ -60,7 +60,7 @@ var envelope = (aggregateID, seq, version) => ({
 var decodeSerializedEvent = (event) => {
   const definition = Durable.get(event.type);
   if (!definition?.durable) {
-    throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` });
+    throw new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` });
   }
   return {
     id: event.id,
@@ -70,19 +70,19 @@ var decodeSerializedEvent = (event) => {
     data: Schema.decodeUnknownSync(definition.data)(event.data)
   };
 };
-var versionedType = Event.versionedType;
-var durable = Event.durable;
-var ephemeral = Event.ephemeral;
-var isSynced = (item) => item.type === "log.synced";
+var versionedType2 = Event.versionedType;
+var durable2 = Event.durable;
+var ephemeral2 = Event.ephemeral;
+var isSynced2 = (item) => item.type === "log.synced";
 var isDefinition = (input) => !Array.isArray(input);
 
-class Service extends Context.Service()("@opencode/Bus") {
+class Service79 extends Context.Service()("@opencode/Bus") {
 }
-function configured(options) {
+function configured12(options) {
   return makeGlobalNode({
-    service: Service,
-    deps: [exports_database.node],
-    layer: Layer.effect(Service, Effect.gen(function* () {
+    service: Service79,
+    deps: [node85],
+    layer: Layer.effect(Service79, Effect.gen(function* () {
       const { Location } = yield* Effect.promise(() => import("../location.js"));
       const { SessionTable } = yield* Effect.promise(() => import("../session/sql.js"));
       const pubsub = {
@@ -92,8 +92,8 @@ function configured(options) {
       };
       const projectors = new Map;
       const listeners = new Array;
-      const durableLocks = exports_keyed_mutex.makeUnsafe();
-      const { db } = yield* exports_database.Service;
+      const durableLocks = makeUnsafe2();
+      const { db } = yield* Service80;
       const logReadPageSize = options?.logReadPageSize ?? 512;
       const persist = options?.persist ?? false;
       const sessions = new Map;
@@ -160,29 +160,29 @@ function configured(options) {
       }));
       function commitDurableEvent(definition, event, input, commit) {
         return Effect.gen(function* () {
-          const durable2 = definition.durable;
-          if (!durable2)
+          const durable = definition.durable;
+          if (!durable)
             return yield* Effect.void;
-          const aggregateID = event.data[durable2.aggregate];
+          const aggregateID = event.data[durable.aggregate];
           if (typeof aggregateID !== "string")
-            return yield* Effect.die(new InvalidDurableEventError({
+            return yield* Effect.die(new InvalidDurableEventError2({
               type: event.type,
-              message: `Expected string aggregate field ${durable2.aggregate}`
+              message: `Expected string aggregate field ${durable.aggregate}`
             }));
           if (input && input.aggregateID !== aggregateID) {
-            yield* Effect.die(new InvalidDurableEventError({
+            yield* Effect.die(new InvalidDurableEventError2({
               type: event.type,
               message: `Aggregate mismatch: expected ${input.aggregateID}, got ${aggregateID}`
             }));
           }
-          const list = projectors.get(versionedType(definition.type, durable2.version)) ?? [];
+          const list = projectors.get(versionedType2(definition.type, durable.version)) ?? [];
           return yield* Effect.uninterruptible(Effect.gen(function* () {
             const committed = yield* db.transaction(() => Effect.gen(function* () {
-              const row = yield* db.select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const row = yield* db.select({ seq: EventSequenceTable2.seq, ownerID: EventSequenceTable2.owner_id }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
               const latest = row?.seq ?? -1;
               const encoded = Schema.encodeUnknownSync(definition.data)(event.data);
               if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
-                yield* Effect.die(new InvalidDurableEventError({
+                yield* Effect.die(new InvalidDurableEventError2({
                   type: event.type,
                   message: `Replay owner mismatch for aggregate ${aggregateID}: expected ${row.ownerID}, got ${input.ownerID ?? "none"}`
                 }));
@@ -190,14 +190,14 @@ function configured(options) {
               if (input && input.seq <= latest) {
                 if (!persist)
                   return;
-                const stored = yield* db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), eq(EventTable.seq, input.seq))).get().pipe(Effect.orDie);
-                if (stored?.id === event.id && stored.type === versionedType(definition.type, durable2.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
+                const stored = yield* db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), eq(EventTable2.seq, input.seq))).get().pipe(Effect.orDie);
+                if (stored?.id === event.id && stored.type === versionedType2(definition.type, durable.version) && stored.created === (event.created ?? 0) && isDeepStrictEqual(stored.data, encoded)) {
                   if (input.ownerID && row?.ownerID == null) {
-                    yield* db.update(EventSequenceTable).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+                    yield* db.update(EventSequenceTable2).set({ owner_id: input.ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
                   }
                   return;
                 }
-                yield* Effect.die(new InvalidDurableEventError({
+                yield* Effect.die(new InvalidDurableEventError2({
                   type: event.type,
                   message: `Replay diverged at aggregate ${aggregateID} sequence ${input.seq}`
                 }));
@@ -207,48 +207,48 @@ function configured(options) {
               }
               const seq = input?.seq ?? latest + 1;
               if (input && seq !== latest + 1) {
-                yield* Effect.die(new InvalidDurableEventError({
+                yield* Effect.die(new InvalidDurableEventError2({
                   type: event.type,
                   message: `Sequence mismatch for aggregate ${aggregateID}: expected ${latest + 1}, got ${seq}`
                 }));
               }
               if (persist) {
-                const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, event.id)).get().pipe(Effect.orDie);
+                const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, event.id)).get().pipe(Effect.orDie);
                 if (stored)
-                  yield* Effect.die(new InvalidDurableEventError({
+                  yield* Effect.die(new InvalidDurableEventError2({
                     type: event.type,
                     message: `Event ${event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
                   }));
               }
-              const committed2 = {
+              const committed = {
                 ...event,
-                durable: { aggregateID, seq, version: durable2.version }
+                durable: { aggregateID, seq, version: durable.version }
               };
-              const route = yield* prepareRoutes([committed2]);
+              const route = yield* prepareRoutes([committed]);
               for (const projector of list) {
-                yield* projector(committed2);
+                yield* projector(committed);
               }
               if (commit)
                 yield* commit(seq);
-              yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
-                target: EventSequenceTable.aggregate_id,
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq, owner_id: input?.ownerID }]).onConflictDoUpdate({
+                target: EventSequenceTable2.aggregate_id,
                 set: {
-                  seq: sql`max(${EventSequenceTable.seq}, ${seq})`,
+                  seq: sql`max(${EventSequenceTable2.seq}, ${seq})`,
                   ...input?.ownerID && row?.ownerID == null ? { owner_id: input.ownerID } : {}
                 }
               }).run().pipe(Effect.orDie);
               if (persist)
-                yield* db.insert(EventTable).values([
+                yield* db.insert(EventTable2).values([
                   {
                     id: event.id,
                     aggregate_id: aggregateID,
                     seq,
                     created: event.created ?? 0,
-                    type: versionedType(definition.type, durable2.version),
+                    type: versionedType2(definition.type, durable.version),
                     data: encoded
                   }
                 ]).run().pipe(Effect.orDie);
-              return { aggregateID, seq, event: committed2, route };
+              return { aggregateID, seq, event: committed, route };
             }), { behavior: "immediate" }).pipe(Effect.orDie);
             if (committed) {
               committed.route();
@@ -261,7 +261,7 @@ function configured(options) {
       function publishEvent(definition, event, commit) {
         return Effect.gen(function* () {
           if (!definition.durable && commit)
-            return yield* Effect.die(new InvalidDurableEventError({
+            return yield* Effect.die(new InvalidDurableEventError2({
               type: event.type,
               message: "Local commit hooks require a durable event"
             }));
@@ -294,40 +294,40 @@ function configured(options) {
           yield* PubSub.publish(pubsub.live, event);
         });
       }
-      function publish(definition, data, options2) {
+      function publish(definition, data, options) {
         return Effect.gen(function* () {
           const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
-          const location = options2?.global ? undefined : options2?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+          const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
           return yield* publishEvent(definition, {
-            id: options2?.id ?? Event.ID.create(),
+            id: options?.id ?? Event.ID.create(),
             created: yield* Clock.currentTimeMillis,
-            ...options2?.metadata ? { metadata: options2.metadata } : {},
+            ...options?.metadata ? { metadata: options.metadata } : {},
             type: definition.type,
             ...location ? { location } : {},
             data
-          }, options2?.commit);
+          }, options?.commit);
         });
       }
       function publishAll(events) {
         return Effect.gen(function* () {
           const serviceLocation = Option.getOrUndefined(yield* Effect.serviceOption(Location.Service));
-          const payloads = yield* Effect.forEach(events, ([definition, data, options2]) => Effect.gen(function* () {
-            const aggregateID2 = data[definition.durable.aggregate];
-            if (typeof aggregateID2 !== "string") {
-              return yield* Effect.die(new InvalidDurableEventError({
+          const payloads = yield* Effect.forEach(events, ([definition, data, options]) => Effect.gen(function* () {
+            const aggregateID = data[definition.durable.aggregate];
+            if (typeof aggregateID !== "string") {
+              return yield* Effect.die(new InvalidDurableEventError2({
                 type: definition.type,
                 message: `Expected string aggregate field ${definition.durable.aggregate}`
               }));
             }
-            const location = options2?.global ? undefined : options2?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
+            const location = options?.global ? undefined : options?.location ?? (serviceLocation ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID } : undefined);
             return {
               definition,
-              aggregateID: aggregateID2,
-              commit: options2?.commit,
+              aggregateID,
+              commit: options?.commit,
               event: {
-                id: options2?.id ?? Event.ID.create(),
+                id: options?.id ?? Event.ID.create(),
                 created: yield* Clock.currentTimeMillis,
-                ...options2?.metadata ? { metadata: options2.metadata } : {},
+                ...options?.metadata ? { metadata: options.metadata } : {},
                 type: definition.type,
                 ...location ? { location } : {},
                 data
@@ -336,14 +336,14 @@ function configured(options) {
           }));
           const aggregateID = payloads[0].aggregateID;
           if (payloads.some((item) => item.aggregateID !== aggregateID)) {
-            return yield* Effect.die(new InvalidDurableEventError({
+            return yield* Effect.die(new InvalidDurableEventError2({
               type: payloads[0].definition.type,
               message: "Published events must belong to the same aggregate"
             }));
           }
           return yield* durableLocks.withLock(aggregateID)(Effect.uninterruptible(Effect.gen(function* () {
             const committed = yield* db.transaction(() => Effect.gen(function* () {
-              const row = yield* db.select({ seq: EventSequenceTable.seq }).from(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
+              const row = yield* db.select({ seq: EventSequenceTable2.seq }).from(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).get().pipe(Effect.orDie);
               const firstSeq = (row?.seq ?? -1) + 1;
               const finalSeq = firstSeq + payloads.length - 1;
               const queued = payloads.map((item, index) => ({
@@ -358,20 +358,20 @@ function configured(options) {
                 const encoded = Schema.encodeUnknownSync(item.definition.data)(item.event.data);
                 if (persist) {
                   if (ids.has(item.event.id))
-                    yield* Effect.die(new InvalidDurableEventError({
+                    yield* Effect.die(new InvalidDurableEventError2({
                       type: item.event.type,
                       message: `Event ${item.event.id} appears more than once in the batch`
                     }));
                   ids.add(item.event.id);
-                  const stored = yield* db.select({ aggregateID: EventTable.aggregate_id, seq: EventTable.seq }).from(EventTable).where(eq(EventTable.id, item.event.id)).get().pipe(Effect.orDie);
+                  const stored = yield* db.select({ aggregateID: EventTable2.aggregate_id, seq: EventTable2.seq }).from(EventTable2).where(eq(EventTable2.id, item.event.id)).get().pipe(Effect.orDie);
                   if (stored)
-                    yield* Effect.die(new InvalidDurableEventError({
+                    yield* Effect.die(new InvalidDurableEventError2({
                       type: item.event.type,
                       message: `Event ${item.event.id} already exists at aggregate ${stored.aggregateID} sequence ${stored.seq}`
                     }));
                 }
                 const event = queued[index];
-                for (const projector of projectors.get(versionedType(item.definition.type, item.definition.durable.version)) ?? []) {
+                for (const projector of projectors.get(versionedType2(item.definition.type, item.definition.durable.version)) ?? []) {
                   yield* projector(event);
                 }
                 if (item.commit)
@@ -382,13 +382,13 @@ function configured(options) {
                     aggregate_id: aggregateID,
                     seq,
                     created: event.created,
-                    type: versionedType(item.definition.type, item.definition.durable.version),
+                    type: versionedType2(item.definition.type, item.definition.durable.version),
                     data: encoded
                   });
               }
-              yield* db.insert(EventSequenceTable).values([{ aggregate_id: aggregateID, seq: finalSeq }]).onConflictDoUpdate({ target: EventSequenceTable.aggregate_id, set: { seq: finalSeq } }).run().pipe(Effect.orDie);
+              yield* db.insert(EventSequenceTable2).values([{ aggregate_id: aggregateID, seq: finalSeq }]).onConflictDoUpdate({ target: EventSequenceTable2.aggregate_id, set: { seq: finalSeq } }).run().pipe(Effect.orDie);
               if (persist)
-                yield* db.insert(EventTable).values(rows).run().pipe(Effect.orDie);
+                yield* db.insert(EventTable2).values(rows).run().pipe(Effect.orDie);
               return { events: queued, route };
             }), { behavior: "immediate" }).pipe(Effect.orDie);
             committed.route();
@@ -400,11 +400,11 @@ function configured(options) {
           })));
         });
       }
-      function replay(event, options2) {
+      function replay(event, options) {
         return Effect.gen(function* () {
           const definition = Durable.get(event.type);
           if (!definition?.durable)
-            return yield* Effect.die(new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }));
+            return yield* Effect.die(new InvalidDurableEventError2({ type: event.type, message: `Unknown durable event type ${event.type}` }));
           yield* durableLocks.withLock(event.aggregateID)(Effect.gen(function* () {
             const payload = {
               id: event.id,
@@ -415,10 +415,10 @@ function configured(options) {
             const committed = yield* commitDurableEvent(definition, payload, {
               seq: event.seq,
               aggregateID: event.aggregateID,
-              ownerID: options2?.ownerID,
-              strictOwner: options2?.strictOwner
+              ownerID: options?.ownerID,
+              strictOwner: options?.strictOwner
             });
-            if (committed && options2?.publish) {
+            if (committed && options?.publish) {
               yield* notify(committed.event, true);
             }
           }));
@@ -426,17 +426,17 @@ function configured(options) {
       }
       function remove(aggregateID) {
         return db.transaction(() => Effect.gen(function* () {
-          yield* db.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run();
-          yield* db.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run();
+          yield* db.delete(EventSequenceTable2).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run();
+          yield* db.delete(EventTable2).where(eq(EventTable2.aggregate_id, aggregateID)).run();
         })).pipe(Effect.tap(() => Effect.sync(() => sessions.delete(aggregateID))), Effect.orDie);
       }
       function claim(aggregateID, ownerID) {
-        return db.update(EventSequenceTable).set({ owner_id: ownerID }).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
+        return db.update(EventSequenceTable2).set({ owner_id: ownerID }).where(eq(EventSequenceTable2.aggregate_id, aggregateID)).run().pipe(Effect.orDie);
       }
       const local = (stream) => Stream.unwrap(Effect.serviceOption(Location.Service).pipe(Effect.map((location) => Option.match(location, {
         onNone: () => stream,
-        onSome: (location2) => {
-          const matches = (ref) => ref.directory === location2.directory && ref.workspaceID === location2.workspaceID;
+        onSome: (location) => {
+          const matches = (ref) => ref.directory === location.directory && ref.workspaceID === location.workspaceID;
           return stream.pipe(Stream.filter((event) => {
             const refs = routes.get(event);
             if (refs)
@@ -449,14 +449,14 @@ function configured(options) {
         if (input === undefined)
           return streamLive();
         if (isDefinition(input)) {
-          return local(Stream.unwrap(getOrCreate(input).pipe(Effect.map((pubsub2) => Stream.fromPubSub(pubsub2)))));
+          return local(Stream.unwrap(getOrCreate(input).pipe(Effect.map((pubsub) => Stream.fromPubSub(pubsub)))));
         }
         const types = new Set(input.map((definition) => definition.type));
         return streamLive().pipe(Stream.filter((event) => types.has(event.type)));
       }
       const streamLive = () => local(Stream.fromPubSub(pubsub.live));
       const readAfter = (aggregateID, after, input) => (options?.beforeAggregateRead?.(aggregateID) ?? Effect.void).pipe(Effect.andThen(Effect.suspend(() => {
-        const query = db.select().from(EventTable).where(and(eq(EventTable.aggregate_id, aggregateID), gt(EventTable.seq, after), lte(EventTable.seq, input.through))).orderBy(asc(EventTable.seq));
+        const query = db.select().from(EventTable2).where(and(eq(EventTable2.aggregate_id, aggregateID), gt(EventTable2.seq, after), lte(EventTable2.seq, input.through))).orderBy(asc(EventTable2.seq));
         return query.limit(input.limit).all();
       })), Effect.orDie, Effect.map((rows) => ({
         seq: rows.at(-1)?.seq,
@@ -499,17 +499,17 @@ function configured(options) {
           page.seq !== undefined && page.seq < through ? Option.some(page.seq) : Option.none()
         ])));
         const wakes = input.follow ? yield* subscribeDurable(input.aggregateID) : undefined;
-        const target = yield* latestSequence(db, input.aggregateID);
+        const target = yield* latestSequence2(db, input.aggregateID);
         const marker = {
           type: "log.synced",
           aggregateID: input.aggregateID,
           ...target >= 0 ? { seq: Event.Seq.make(target) } : {}
         };
-        const replay2 = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
+        const replay = readThrough(target).pipe(Stream.concat(Stream.make(marker)));
         if (!wakes)
-          return replay2;
-        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence(db, input.aggregateID)), Stream.filter((target2) => target2 > sequence), Stream.flatMap((target2) => readThrough(target2)));
-        return Stream.concat(replay2, live);
+          return replay;
+        const live = Stream.fromSubscription(wakes).pipe(Stream.mapEffect(() => latestSequence2(db, input.aggregateID)), Stream.filter((target) => target > sequence), Stream.flatMap((target) => readThrough(target)));
+        return Stream.concat(replay, live);
       }));
       const listen = (listener) => Effect.sync(() => {
         listeners.push(listener);
@@ -520,12 +520,12 @@ function configured(options) {
         });
       });
       const project = (definition, projector) => Effect.sync(() => {
-        const key = definition.durable ? versionedType(definition.type, definition.durable.version) : definition.type;
+        const key = definition.durable ? versionedType2(definition.type, definition.durable.version) : definition.type;
         const list = projectors.get(key) ?? [];
         list.push((event) => projector(event));
         projectors.set(key, list);
       });
-      return Service.of({
+      return Service79.of({
         publish,
         publishAll,
         subscribe,
@@ -539,6 +539,6 @@ function configured(options) {
     }))
   });
 }
-var node = configured();
+var node84 = configured12();
 
-export { latestSequence, reserveSequence, InvalidDurableEventError, versionedType, durable, ephemeral, isSynced, Service, configured, node, exports_bus };
+export { latestSequence2, reserveSequence2, InvalidDurableEventError2, versionedType2, durable2, ephemeral2, isSynced2, Service79, configured12, node84, exports_bus };