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

package/dist/ide-event.d.ts

@@ -6,15 +6,6 @@ export declare const Installed: 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<"ide.installed">;
-    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 Installed: Schema.Struct<{
         readonly ide: Schema.String;
     }>;
 }> & {
+    type: "ide.installed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly ide: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "ide.installed";
 };
 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<"ide.installed">;
-    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 ide: Schema.String;
     }>;
 }> & {
+    type: "ide.installed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly ide: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "ide.installed";
 }];

package/dist/ide-event.js

@@ -1,7 +1,7 @@
 export * as IdeEvent from "./ide-event.js";
 import { Schema } from "effect";
 import { Event } from "./event.js";
-export const Installed = Event.define({
+export const Installed = Event.ephemeral({
     type: "ide.installed",
     schema: {
         ide: Schema.String,

package/dist/installation-event.d.ts

@@ -6,15 +6,6 @@ export declare const Updated: 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<"installation.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 Updated: Schema.Struct<{
         readonly version: Schema.String;
     }>;
 }> & {
+    type: "installation.updated";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly version: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "installation.updated";
 };
 export declare const UpdateAvailable: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -53,15 +42,6 @@ export declare const UpdateAvailable: 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<"installation.update-available">;
-    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,14 +65,12 @@ export declare const UpdateAvailable: Schema.Struct<{
         readonly version: Schema.String;
     }>;
 }> & {
+    type: "installation.update-available";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly version: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "installation.update-available";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -100,15 +78,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<"installation.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"> & {
@@ -132,29 +101,18 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly version: Schema.String;
     }>;
 }> & {
+    type: "installation.updated";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly version: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "installation.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<"installation.update-available">;
-    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"> & {
@@ -178,12 +136,10 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly version: Schema.String;
     }>;
 }> & {
+    type: "installation.update-available";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly version: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "installation.update-available";
 }];

package/dist/installation-event.js

@@ -1,13 +1,13 @@
 export * as InstallationEvent from "./installation-event.js";
 import { Schema } from "effect";
 import { Event } from "./event.js";
-export const Updated = Event.define({
+export const Updated = Event.ephemeral({
     type: "installation.updated",
     schema: {
         version: Schema.String,
     },
 });
-export const UpdateAvailable = Event.define({
+export const UpdateAvailable = Event.ephemeral({
     type: "installation.update-available",
     schema: {
         version: Schema.String,

package/dist/integration.d.ts

@@ -253,15 +253,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<"integration.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"> & {
@@ -283,12 +274,10 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{}>;
     }> & {
-        data: Schema.Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "integration.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
     };
     ConnectionUpdated: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -296,15 +285,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<"integration.connection.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"> & {
@@ -328,14 +308,12 @@ export declare const Event: {
             readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
         }>;
     }> & {
+        type: "integration.connection.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "integration.connection.updated";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -343,15 +321,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<"integration.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"> & {
@@ -373,27 +342,16 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{}>;
     }> & {
-        data: Schema.Struct<{}>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
         type: "integration.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
     }, 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<"integration.connection.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"> & {
@@ -417,14 +375,12 @@ export declare const Event: {
             readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
         }>;
     }> & {
+        type: "integration.connection.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "integration.connection.updated";
     }];
 };
 export interface Ref extends Schema.Schema.Type<typeof Ref> {

package/dist/integration.js

@@ -1,7 +1,7 @@
 export * as Integration from "./integration.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { Connection } from "./connection.js";
 import { ascending } from "./identifier.js";
 import { statics } from "./schema.js";
@@ -50,11 +50,11 @@ export const Method = Schema.Union([OAuthMethod, KeyMethod, EnvMethod])
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "Integration.Method" });
 export const Inputs = Schema.Record(Schema.String, Schema.String).annotate({ identifier: "Integration.Inputs" });
-const Updated = define({
+const Updated = ephemeral({
     type: "integration.updated",
     schema: {},
 });
-const ConnectionUpdated = define({
+const ConnectionUpdated = ephemeral({
     type: "integration.connection.updated",
     schema: { integrationID: ID },
 });

package/dist/lsp-event.d.ts

@@ -5,15 +5,6 @@ export declare const Updated: import("effect/Schema").Struct<{
     };
     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<"lsp.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"> & {
@@ -35,12 +26,10 @@ export declare const Updated: import("effect/Schema").Struct<{
     }>>, never, never>;
     readonly data: import("effect/Schema").Struct<{}>;
 }> & {
-    data: import("effect/Schema").Struct<{}>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
     type: "lsp.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
 };
 export declare const Definitions: readonly [import("effect/Schema").Struct<{
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
@@ -48,15 +37,6 @@ export declare const Definitions: readonly [import("effect/Schema").Struct<{
     };
     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<"lsp.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"> & {
@@ -78,10 +58,8 @@ export declare const Definitions: readonly [import("effect/Schema").Struct<{
     }>>, never, never>;
     readonly data: import("effect/Schema").Struct<{}>;
 }> & {
-    data: import("effect/Schema").Struct<{}>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
     type: "lsp.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
 }];

package/dist/lsp-event.js

@@ -1,4 +1,4 @@
 export * as LspEvent from "./lsp-event.js";
 import { Event } from "./event.js";
-export const Updated = Event.define({ type: "lsp.updated", schema: {} });
+export const Updated = Event.ephemeral({ type: "lsp.updated", schema: {} });
 export const Definitions = Event.inventory(Updated);

package/dist/mcp-event.d.ts

@@ -6,15 +6,6 @@ export declare const ToolsChanged: 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<"mcp.tools.changed">;
-    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 ToolsChanged: Schema.Struct<{
         readonly server: Schema.String;
     }>;
 }> & {
+    type: "mcp.tools.changed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly server: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.tools.changed";
 };
 export declare const BrowserOpenFailed: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -53,15 +42,6 @@ export declare const BrowserOpenFailed: 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<"mcp.browser.open.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"> & {
@@ -86,15 +66,13 @@ export declare const BrowserOpenFailed: Schema.Struct<{
         readonly url: Schema.String;
     }>;
 }> & {
+    type: "mcp.browser.open.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly mcpName: Schema.String;
         readonly url: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.browser.open.failed";
 };
 export declare const StatusChanged: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -102,15 +80,6 @@ export declare const StatusChanged: 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<"mcp.status.changed">;
-    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,14 +103,12 @@ export declare const StatusChanged: Schema.Struct<{
         readonly server: Schema.String;
     }>;
 }> & {
+    type: "mcp.status.changed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly server: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.status.changed";
 };
 export declare const Definitions: readonly [Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -149,15 +116,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<"mcp.tools.changed">;
-    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"> & {
@@ -181,29 +139,18 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly server: Schema.String;
     }>;
 }> & {
+    type: "mcp.tools.changed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly server: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.tools.changed";
 }, 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<"mcp.browser.open.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"> & {
@@ -228,30 +175,19 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly url: Schema.String;
     }>;
 }> & {
+    type: "mcp.browser.open.failed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly mcpName: Schema.String;
         readonly url: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.browser.open.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<"mcp.status.changed">;
-    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"> & {
@@ -275,12 +211,10 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly server: Schema.String;
     }>;
 }> & {
+    type: "mcp.status.changed";
+    durability: "ephemeral";
+    durable: undefined;
     data: Schema.Struct<{
         readonly server: Schema.String;
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "mcp.status.changed";
 }];