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

package/dist/mcp-event.js

@@ -1,13 +1,13 @@
 export * as McpEvent from "./mcp-event.js";
 import { Schema } from "effect";
 import { Event } from "./event.js";
-export const ToolsChanged = Event.define({
+export const ToolsChanged = Event.ephemeral({
     type: "mcp.tools.changed",
     schema: {
         server: Schema.String,
     },
 });
-export const BrowserOpenFailed = Event.define({
+export const BrowserOpenFailed = Event.ephemeral({
     type: "mcp.browser.open.failed",
     schema: {
         mcpName: Schema.String,
@@ -16,7 +16,7 @@ export const BrowserOpenFailed = Event.define({
 });
 // Emitted whenever a server's connection status settles (connected, failed, needs_auth, closed) so
 // observers can refresh status without polling.
-export const StatusChanged = Event.define({
+export const StatusChanged = Event.ephemeral({
     type: "mcp.status.changed",
     schema: {
         server: Schema.String,

package/dist/models-dev.d.ts

@@ -6,15 +6,6 @@ export declare const Event: {
         };
         readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
         readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
-        readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
             readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
             readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
@@ -36,12 +27,10 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: import("effect/Schema").Struct<{}>;
     }> & {
-        data: import("effect/Schema").Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
     };
     Definitions: readonly [import("effect/Schema").Struct<{
         readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
@@ -49,15 +38,6 @@ export declare const Event: {
         };
         readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
         readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
-        readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
             readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
             readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
@@ -79,11 +59,9 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: import("effect/Schema").Struct<{}>;
     }> & {
-        data: import("effect/Schema").Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
     }];
 };

package/dist/models-dev.js

@@ -1,6 +1,6 @@
 export * as ModelsDev from "./models-dev.js";
-import { define, inventory } from "./event.js";
-const Refreshed = define({
+import { ephemeral, inventory } from "./event.js";
+const Refreshed = ephemeral({
     type: "models-dev.refreshed",
     schema: {},
 });

package/dist/permission.d.ts

@@ -43,15 +43,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.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"> & {
@@ -94,6 +85,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "permission.v2.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -116,11 +110,6 @@ export declare const Event: {
                 create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.v2.asked";
     };
     Replied: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -128,15 +117,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.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"> & {
@@ -167,6 +147,9 @@ export declare const Event: {
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
     }> & {
+        type: "permission.v2.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -177,11 +160,6 @@ export declare const Event: {
             };
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.v2.replied";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -189,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<"permission.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"> & {
@@ -240,6 +209,9 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "permission.v2.asked";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -262,26 +234,12 @@ export declare const Event: {
                 create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.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<"permission.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"> & {
@@ -312,6 +270,9 @@ export declare const Event: {
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
     }> & {
+        type: "permission.v2.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -322,11 +283,6 @@ export declare const Event: {
             };
             readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "permission.v2.replied";
     }];
 };
 export declare const Effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;

package/dist/permission.js

@@ -1,7 +1,7 @@
 export * as Permission from "./permission.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";
@@ -26,8 +26,8 @@ export const Request = Schema.Struct({
     ...RequestFields,
 }).annotate({ identifier: "PermissionV2.Request" });
 export const Reply = Schema.Literals(["once", "always", "reject"]).annotate({ identifier: "PermissionV2.Reply" });
-const Asked = define({ type: "permission.v2.asked", schema: Request.fields });
-const Replied = define({
+const Asked = ephemeral({ type: "permission.v2.asked", schema: Request.fields });
+const Replied = ephemeral({
     type: "permission.v2.replied",
     schema: {
         sessionID: SessionID,

package/dist/plugin.d.ts

@@ -14,15 +14,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<"plugin.added">;
-        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,14 +37,12 @@ export declare const Event: {
             readonly id: Schema.brand<Schema.String, "Plugin.ID">;
         }>;
     }> & {
+        type: "plugin.added";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Plugin.ID">;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "plugin.added";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -61,15 +50,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<"plugin.added">;
-        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"> & {
@@ -93,13 +73,11 @@ export declare const Event: {
             readonly id: Schema.brand<Schema.String, "Plugin.ID">;
         }>;
     }> & {
+        type: "plugin.added";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Plugin.ID">;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "plugin.added";
     }];
 };

package/dist/plugin.js

@@ -1,11 +1,11 @@
 export * as Plugin from "./plugin.js";
 import { Schema } from "effect";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"));
 export const Info = Schema.Struct({
     id: ID,
 }).annotate({ identifier: "Plugin.Info" });
-const Added = define({
+const Added = ephemeral({
     type: "plugin.added",
     schema: { id: ID },
 });

package/dist/project-directories.d.ts

@@ -6,15 +6,6 @@ export declare const Event: {
         };
         readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
         readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
             readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
             readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
@@ -40,16 +31,14 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "project.directories.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: import("effect/Schema").Struct<{
             readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
                 global: string & import("effect/Brand").Brand<"Project.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "project.directories.updated";
     };
     Definitions: readonly [import("effect/Schema").Struct<{
         readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
@@ -57,15 +46,6 @@ export declare const Event: {
         };
         readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
         readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly aggregateID: import("effect/Schema").String;
-            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
-            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
-        }>>, never, never>;
         readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
             readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
             readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
@@ -91,15 +71,13 @@ export declare const Event: {
             };
         }>;
     }> & {
+        type: "project.directories.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: import("effect/Schema").Struct<{
             readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
                 global: string & import("effect/Brand").Brand<"Project.ID">;
             };
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "project.directories.updated";
     }];
 };

package/dist/project-directories.js

@@ -1,7 +1,7 @@
 export * as ProjectDirectories from "./project-directories.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { Project } from "./project.js";
-const Updated = define({
+const Updated = ephemeral({
     type: "project.directories.updated",
     schema: { projectID: Project.ID },
 });

package/dist/project.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<"project.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"> & {
@@ -144,6 +135,9 @@ export declare const Event: {
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
     }> & {
+        type: "project.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Project.ID"> & {
                 global: string & import("effect/Brand").Brand<"Project.ID">;
@@ -172,11 +166,6 @@ export declare const Event: {
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "project.updated";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -184,15 +173,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<"project.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"> & {
@@ -241,6 +221,9 @@ export declare const Event: {
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
     }> & {
+        type: "project.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Project.ID"> & {
                 global: string & import("effect/Brand").Brand<"Project.ID">;
@@ -269,10 +252,5 @@ export declare const Event: {
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "project.updated";
     }];
 };

package/dist/project.js

@@ -1,6 +1,6 @@
 export * as Project from "./project.js";
 import { Schema } from "effect";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { AbsolutePath, NonNegativeInt, optional } from "./schema.js";
 import { ProjectID } from "./project-id.js";
 export const ID = ProjectID;
@@ -40,5 +40,5 @@ export const Info = Schema.Struct({
     time: Time,
     sandboxes: Schema.Array(Schema.String),
 }).annotate({ identifier: "Project" });
-const Updated = define({ type: "project.updated", schema: Info.fields });
+const Updated = ephemeral({ type: "project.updated", schema: Info.fields });
 export const Event = { Updated, Definitions: inventory(Updated) };