@opencode-ai/schema 0.0.0-next-14798 → 0.0.0-next-14801

package/dist/v1/legacy-event.d.ts

@@ -6,15 +6,6 @@ export declare const CommandExecuted: Schema.Struct<{
     };
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
     readonly type: Schema.Literal<"command.executed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -46,6 +37,9 @@ export declare const CommandExecuted: Schema.Struct<{
         };
     }>;
 }> & {
+    type: "command.executed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
@@ -57,11 +51,6 @@ export declare const CommandExecuted: Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "command.executed";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -69,15 +58,6 @@ export declare const Definitions: readonly [Schema.Struct<{
     };
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
     readonly type: Schema.Literal<"command.executed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -109,6 +89,9 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
     }>;
 }> & {
+    type: "command.executed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
@@ -120,9 +103,4 @@ export declare const Definitions: readonly [Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "command.executed";
 }];

package/dist/v1/legacy-event.js

@@ -1,9 +1,9 @@
 export * as LegacyEvent from "./legacy-event.js";
 import { Schema } from "effect";
-import { define, inventory } from "../event.js";
+import { ephemeral, inventory } from "../event.js";
 import { SessionID } from "../session-id.js";
 import { SessionV1 } from "./session.js";
-export const CommandExecuted = define({
+export const CommandExecuted = ephemeral({
     type: "command.executed",
     schema: {
         name: Schema.String,

package/dist/v1/permission.d.ts

@@ -88,15 +88,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"permission.asked">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -134,6 +125,9 @@ export declare const Event: {
             }>>;
         }>;
     }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PermissionID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionID">;
@@ -151,11 +145,6 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.asked";
     };
     Replied: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -163,15 +152,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"permission.replied">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -202,6 +182,9 @@ export declare const Event: {
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
     }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -212,11 +195,6 @@ export declare const Event: {
             };
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.replied";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -224,15 +202,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"permission.asked">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -270,6 +239,9 @@ export declare const Event: {
             }>>;
         }>;
     }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PermissionID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionID">;
@@ -287,26 +259,12 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.asked";
     }, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Event.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"permission.replied">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -337,6 +295,9 @@ export declare const Event: {
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
     }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -347,10 +308,5 @@ export declare const Event: {
             };
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.replied";
     }];
 };

package/dist/v1/permission.js

@@ -1,6 +1,6 @@
 export * as PermissionV1 from "./permission.js";
 import { Schema } from "effect";
-import { define, inventory } from "../event.js";
+import { ephemeral, inventory } from "../event.js";
 import { ascending } from "../identifier.js";
 import { Project } from "../project.js";
 import { statics } from "../schema.js";
@@ -33,8 +33,8 @@ export const AskInput = Schema.Struct({ ...Request.fields, id: Schema.optional(I
 export const ReplyInput = Schema.Struct({ requestID: ID, ...ReplyBody.fields }).annotate({
     identifier: "PermissionReplyInput",
 });
-const Asked = define({ type: "permission.asked", schema: Request.fields });
-const Replied = define({
+const Asked = ephemeral({ type: "permission.asked", schema: Request.fields });
+const Replied = ephemeral({
     type: "permission.replied",
     schema: { sessionID: SessionID, requestID: ID, reply: Reply },
 });

package/dist/v1/question.d.ts

@@ -87,15 +87,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.asked">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -141,6 +132,9 @@ export declare const Event: {
             }>>;
         }>;
     }> & {
+        type: "question.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "QuestionID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
@@ -166,11 +160,6 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.asked";
     };
     Replied: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -178,15 +167,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.replied">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -217,6 +197,9 @@ export declare const Event: {
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
     }> & {
+        type: "question.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -227,11 +210,6 @@ export declare const Event: {
             };
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.replied";
     };
     Rejected: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -239,15 +217,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.rejected">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -277,6 +246,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "question.rejected";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -286,11 +258,6 @@ export declare const Event: {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.rejected";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -298,15 +265,6 @@ export declare const Event: {
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.asked">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -352,6 +310,9 @@ export declare const Event: {
             }>>;
         }>;
     }> & {
+        type: "question.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "QuestionID"> & {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
@@ -377,26 +338,12 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.asked";
     }, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Event.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.replied">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -427,6 +374,9 @@ export declare const Event: {
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
     }> & {
+        type: "question.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -437,26 +387,12 @@ export declare const Event: {
             };
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.replied";
     }, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Event.ID">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly type: Schema.Literal<"question.rejected">;
-        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly aggregateID: Schema.String;
-            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-            readonly version: Schema.brand<Schema.Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
             readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -486,6 +422,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "question.rejected";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -495,10 +434,5 @@ export declare const Event: {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.rejected";
     }];
 };

package/dist/v1/question.js

@@ -1,6 +1,6 @@
 export * as QuestionV1 from "./question.js";
 import { Schema } from "effect";
-import { define, inventory } from "../event.js";
+import { ephemeral, inventory } from "../event.js";
 import { ascending } from "../identifier.js";
 import { statics } from "../schema.js";
 import { SessionID } from "../session-id.js";
@@ -46,9 +46,9 @@ export const Replied = Schema.Struct({
 export const Rejected = Schema.Struct({ sessionID: SessionID, requestID: ID }).annotate({
     identifier: "QuestionRejected",
 });
-const Asked = define({ type: "question.asked", schema: Request.fields });
-const RepliedEvent = define({ type: "question.replied", schema: Replied.fields });
-const RejectedEvent = define({ type: "question.rejected", schema: Rejected.fields });
+const Asked = ephemeral({ type: "question.asked", schema: Request.fields });
+const RepliedEvent = ephemeral({ type: "question.replied", schema: Replied.fields });
+const RejectedEvent = ephemeral({ type: "question.rejected", schema: Rejected.fields });
 export const Event = {
     Asked,
     Replied: RepliedEvent,