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

package/dist/v1/session.js

@@ -1,6 +1,6 @@
 export * as SessionV1 from "./session.js";
 import { Effect, Schema, Types } from "effect";
-import { define, inventory } from "../event.js";
+import { durable, ephemeral, inventory } from "../event.js";
 import { FileDiff } from "../file-diff.js";
 import { Project } from "../project.js";
 import { Provider } from "../provider.js";
@@ -443,7 +443,7 @@ export const SessionInfo = Schema.Struct({
     revert: optional(SessionRevert),
 }).annotate({ identifier: "Session" });
 const events = {
-    Created: define({
+    Created: durable({
         type: "session.created",
         ...options,
         schema: {
@@ -451,7 +451,7 @@ const events = {
             info: SessionInfo,
         },
     }),
-    Updated: define({
+    Updated: durable({
         type: "session.updated",
         ...options,
         schema: {
@@ -459,7 +459,7 @@ const events = {
             info: SessionInfo,
         },
     }),
-    Deleted: define({
+    Deleted: durable({
         type: "session.deleted",
         ...options,
         schema: {
@@ -467,7 +467,7 @@ const events = {
             info: SessionInfo,
         },
     }),
-    MessageUpdated: define({
+    MessageUpdated: durable({
         type: "message.updated",
         ...options,
         schema: {
@@ -475,7 +475,7 @@ const events = {
             info: Info,
         },
     }),
-    MessageRemoved: define({
+    MessageRemoved: durable({
         type: "message.removed",
         ...options,
         schema: {
@@ -483,7 +483,7 @@ const events = {
             messageID: MessageID,
         },
     }),
-    PartUpdated: define({
+    PartUpdated: durable({
         type: "message.part.updated",
         ...options,
         schema: {
@@ -492,7 +492,7 @@ const events = {
             time: Schema.Finite,
         },
     }),
-    PartRemoved: define({
+    PartRemoved: durable({
         type: "message.part.removed",
         ...options,
         schema: {
@@ -502,7 +502,7 @@ const events = {
         },
     }),
 };
-export const PartDelta = define({
+export const PartDelta = ephemeral({
     type: "message.part.delta",
     schema: {
         sessionID: SessionID,
@@ -512,14 +512,14 @@ export const PartDelta = define({
         delta: Schema.String,
     },
 });
-export const Diff = define({
+export const Diff = ephemeral({
     type: "session.diff",
     schema: {
         sessionID: SessionID,
         diff: Schema.Array(FileDiff.Info),
     },
 });
-export const Error = define({
+export const Error = ephemeral({
     type: "session.error",
     schema: {
         sessionID: Schema.optional(SessionID),

package/dist/vcs-event.d.ts

@@ -6,15 +6,6 @@ export declare const BranchUpdated: 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<"vcs.branch.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"> & {
@@ -38,14 +29,12 @@ export declare const BranchUpdated: Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
 }> & {
+    type: "vcs.branch.updated";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "vcs.branch.updated";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -53,15 +42,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<"vcs.branch.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"> & {
@@ -85,12 +65,10 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
 }> & {
+    type: "vcs.branch.updated";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "vcs.branch.updated";
 }];

package/dist/vcs-event.js

@@ -2,7 +2,7 @@ export * as VcsEvent from "./vcs-event.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
 import { Event } from "./event.js";
-export const BranchUpdated = Event.define({
+export const BranchUpdated = Event.ephemeral({
     type: "vcs.branch.updated",
     schema: {
         branch: optional(Schema.String),

package/dist/workspace-event.d.ts

@@ -15,15 +15,6 @@ export declare const Ready: 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<"workspace.ready">;
-    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"> & {
@@ -47,14 +38,12 @@ export declare const Ready: Schema.Struct<{
         readonly name: Schema.String;
     }>;
 }> & {
+    type: "workspace.ready";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.ready";
 };
 export declare const Failed: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -62,15 +51,6 @@ export declare const Failed: 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<"workspace.failed">;
-    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"> & {
@@ -94,14 +74,12 @@ export declare const Failed: Schema.Struct<{
         readonly message: Schema.String;
     }>;
 }> & {
+    type: "workspace.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly message: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.failed";
 };
 export declare const Status: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -109,15 +87,6 @@ export declare const Status: 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<"workspace.status">;
-    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"> & {
@@ -145,6 +114,9 @@ export declare const Status: Schema.Struct<{
         readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
     }>;
 }> & {
+    type: "workspace.status";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
             ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
@@ -152,11 +124,6 @@ export declare const Status: Schema.Struct<{
         };
         readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.status";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -164,15 +131,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<"workspace.ready">;
-    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"> & {
@@ -196,29 +154,18 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly name: Schema.String;
     }>;
 }> & {
+    type: "workspace.ready";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.ready";
 }, 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<"workspace.failed">;
-    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"> & {
@@ -242,29 +189,18 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly message: Schema.String;
     }>;
 }> & {
+    type: "workspace.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly message: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.failed";
 }, 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<"workspace.status">;
-    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"> & {
@@ -292,6 +228,9 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
     }>;
 }> & {
+    type: "workspace.status";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
             ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
@@ -299,9 +238,4 @@ export declare const Definitions: readonly [Schema.Struct<{
         };
         readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "workspace.status";
 }];

package/dist/workspace-event.js

@@ -6,19 +6,19 @@ export const ConnectionStatus = Schema.Struct({
     workspaceID: WorkspaceID,
     status: Schema.Literals(["connected", "connecting", "disconnected", "error"]),
 }).annotate({ identifier: "WorkspaceEvent.ConnectionStatus" });
-export const Ready = Event.define({
+export const Ready = Event.ephemeral({
     type: "workspace.ready",
     schema: {
         name: Schema.String,
     },
 });
-export const Failed = Event.define({
+export const Failed = Event.ephemeral({
     type: "workspace.failed",
     schema: {
         message: Schema.String,
     },
 });
-export const Status = Event.define({
+export const Status = Event.ephemeral({
     type: "workspace.status",
     schema: ConnectionStatus.fields,
 });

package/dist/worktree-event.d.ts

@@ -6,15 +6,6 @@ export declare const Ready: 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<"worktree.ready">;
-    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"> & {
@@ -39,15 +30,13 @@ export declare const Ready: Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
 }> & {
+    type: "worktree.ready";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "worktree.ready";
 };
 export declare const Failed: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -55,15 +44,6 @@ export declare const Failed: 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<"worktree.failed">;
-    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"> & {
@@ -87,14 +67,12 @@ export declare const Failed: Schema.Struct<{
         readonly message: Schema.String;
     }>;
 }> & {
+    type: "worktree.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly message: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "worktree.failed";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -102,15 +80,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<"worktree.ready">;
-    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"> & {
@@ -135,30 +104,19 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
 }> & {
+    type: "worktree.ready";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly name: Schema.String;
         readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "worktree.ready";
 }, 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<"worktree.failed">;
-    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"> & {
@@ -182,12 +140,10 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly message: Schema.String;
     }>;
 }> & {
+    type: "worktree.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly message: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "worktree.failed";
 }];

package/dist/worktree-event.js

@@ -2,14 +2,14 @@ export * as WorktreeEvent from "./worktree-event.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
 import { Event } from "./event.js";
-export const Ready = Event.define({
+export const Ready = Event.ephemeral({
     type: "worktree.ready",
     schema: {
         name: Schema.String,
         branch: optional(Schema.String),
     },
 });
-export const Failed = Event.define({
+export const Failed = Event.ephemeral({
     type: "worktree.failed",
     schema: {
         message: Schema.String,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-next-14798",
+  "version": "0.0.0-next-14801",
   "type": "module",
   "license": "MIT",
   "repository": {