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

package/dist/pty.d.ts

@@ -27,15 +27,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<"pty.created">;
-        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"> & {
@@ -71,6 +62,9 @@ export declare const Event: {
             }>;
         }>;
     }> & {
+        type: "pty.created";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
                 readonly id: Schema.brand<Schema.String, "PtyID"> & {
@@ -86,11 +80,6 @@ export declare const Event: {
                 readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.created";
     };
     Updated: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -98,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<"pty.updated">;
-        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"> & {
@@ -142,6 +122,9 @@ export declare const Event: {
             }>;
         }>;
     }> & {
+        type: "pty.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
                 readonly id: Schema.brand<Schema.String, "PtyID"> & {
@@ -157,11 +140,6 @@ export declare const Event: {
                 readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.updated";
     };
     Exited: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -169,15 +147,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<"pty.exited">;
-        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"> & {
@@ -205,6 +174,9 @@ export declare const Event: {
             readonly exitCode: Schema.Int;
         }>;
     }> & {
+        type: "pty.exited";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PtyID"> & {
                 create: () => string & import("effect/Brand").Brand<"PtyID">;
@@ -212,11 +184,6 @@ export declare const Event: {
             };
             readonly exitCode: Schema.Int;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.exited";
     };
     Deleted: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -224,15 +191,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<"pty.deleted">;
-        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"> & {
@@ -259,17 +217,15 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "pty.deleted";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PtyID"> & {
                 create: () => string & import("effect/Brand").Brand<"PtyID">;
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.deleted";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -277,15 +233,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<"pty.created">;
-        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"> & {
@@ -321,6 +268,9 @@ export declare const Event: {
             }>;
         }>;
     }> & {
+        type: "pty.created";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
                 readonly id: Schema.brand<Schema.String, "PtyID"> & {
@@ -336,26 +286,12 @@ export declare const Event: {
                 readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.created";
     }, 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<"pty.updated">;
-        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"> & {
@@ -391,6 +327,9 @@ export declare const Event: {
             }>;
         }>;
     }> & {
+        type: "pty.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
                 readonly id: Schema.brand<Schema.String, "PtyID"> & {
@@ -406,26 +345,12 @@ export declare const Event: {
                 readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.updated";
     }, 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<"pty.exited">;
-        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"> & {
@@ -453,6 +378,9 @@ export declare const Event: {
             readonly exitCode: Schema.Int;
         }>;
     }> & {
+        type: "pty.exited";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PtyID"> & {
                 create: () => string & import("effect/Brand").Brand<"PtyID">;
@@ -460,26 +388,12 @@ export declare const Event: {
             };
             readonly exitCode: Schema.Int;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.exited";
     }, 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<"pty.deleted">;
-        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"> & {
@@ -506,17 +420,15 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "pty.deleted";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "PtyID"> & {
                 create: () => string & import("effect/Brand").Brand<"PtyID">;
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "pty.deleted";
     }];
 };
 export declare const CreateInput: Schema.Struct<{

package/dist/pty.js

@@ -1,7 +1,7 @@
 export * as Pty from "./pty.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, PositiveInt, statics } from "./schema.js";
 const IDSchema = Schema.String.check(Schema.isStartsWith("pty")).pipe(Schema.brand("PtyID"));
@@ -22,10 +22,10 @@ export const Info = Schema.Struct({
     pid: NonNegativeInt,
     exitCode: optional(NonNegativeInt),
 }).annotate({ identifier: "Pty" });
-const Created = define({ type: "pty.created", schema: { info: Info } });
-const Updated = define({ type: "pty.updated", schema: { info: Info } });
-const Exited = define({ type: "pty.exited", schema: { id: ID, exitCode: NonNegativeInt } });
-const Deleted = define({ type: "pty.deleted", schema: { id: ID } });
+const Created = ephemeral({ type: "pty.created", schema: { info: Info } });
+const Updated = ephemeral({ type: "pty.updated", schema: { info: Info } });
+const Exited = ephemeral({ type: "pty.exited", schema: { id: ID, exitCode: NonNegativeInt } });
+const Deleted = ephemeral({ type: "pty.deleted", schema: { id: ID } });
 export const Event = { Created, Updated, Exited, Deleted, Definitions: inventory(Created, Updated, Exited, Deleted) };
 export const CreateInput = Schema.Struct({
     command: optional(Schema.String),

package/dist/question.d.ts

@@ -83,15 +83,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.v2.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"> & {
@@ -139,6 +130,9 @@ export declare const Event: {
             }>>, never, never>;
         }>;
     }> & {
+        type: "question.v2.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
@@ -166,11 +160,6 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>, never, never>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.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.v2.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"> & {
@@ -218,6 +198,9 @@ export declare const Event: {
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
     }> & {
+        type: "question.v2.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -229,11 +212,6 @@ export declare const Event: {
             };
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.replied";
     };
     Rejected: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -241,15 +219,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.v2.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"> & {
@@ -280,6 +249,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "question.v2.rejected";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -290,11 +262,6 @@ export declare const Event: {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.rejected";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -302,15 +269,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.v2.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"> & {
@@ -358,6 +316,9 @@ export declare const Event: {
             }>>, never, never>;
         }>;
     }> & {
+        type: "question.v2.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
@@ -385,26 +346,12 @@ export declare const Event: {
                 readonly callID: Schema.String;
             }>>, never, never>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.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.v2.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"> & {
@@ -436,6 +383,9 @@ export declare const Event: {
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
     }> & {
+        type: "question.v2.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -447,26 +397,12 @@ export declare const Event: {
             };
             readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.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.v2.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"> & {
@@ -497,6 +433,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "question.v2.rejected";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -507,10 +446,5 @@ export declare const Event: {
                 ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "question.v2.rejected";
     }];
 };

package/dist/question.js

@@ -1,7 +1,7 @@
 export * as Question from "./question.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { SessionID } from "./session-id.js";
 import { statics } from "./schema.js";
@@ -45,8 +45,8 @@ export const Reply = Schema.Struct({
         description: "User answers in order of questions (each answer is an array of selected labels)",
     }),
 }).annotate({ identifier: "QuestionV2.Reply" });
-const Asked = define({ type: "question.v2.asked", schema: Request.fields });
-const Replied = define({
+const Asked = ephemeral({ type: "question.v2.asked", schema: Request.fields });
+const Replied = ephemeral({
     type: "question.v2.replied",
     schema: {
         sessionID: SessionID,
@@ -54,7 +54,7 @@ const Replied = define({
         answers: Schema.Array(Answer),
     },
 });
-const Rejected = define({
+const Rejected = ephemeral({
     type: "question.v2.rejected",
     schema: {
         sessionID: SessionID,

package/dist/reference.d.ts

@@ -7,15 +7,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<"reference.updated">;
-        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"> & {
@@ -37,12 +28,10 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{}>;
     }> & {
-        data: Schema.Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "reference.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -50,15 +39,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<"reference.updated">;
-        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"> & {
@@ -80,12 +60,10 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{}>;
     }> & {
-        data: Schema.Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "reference.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
     }];
 };
 export interface LocalSource extends Schema.Schema.Type<typeof LocalSource> {

package/dist/reference.js

@@ -1,9 +1,9 @@
 export * as Reference from "./reference.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { AbsolutePath } from "./schema.js";
-const Updated = define({ type: "reference.updated", schema: {} });
+const Updated = ephemeral({ type: "reference.updated", schema: {} });
 export const Event = { Updated, Definitions: inventory(Updated) };
 export const LocalSource = Schema.Struct({
     type: Schema.Literal("local"),