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

package/dist/event-manifest.js

@@ -34,8 +34,8 @@ import { TuiEvent } from "./tui-event.js";
 import { VcsEvent } from "./vcs-event.js";
 import { WorkspaceEvent } from "./workspace-event.js";
 import { WorktreeEvent } from "./worktree-event.js";
-const sessionV1DurableDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durable !== undefined);
-const sessionV1LiveDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durable === undefined);
+const sessionV1DurableDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durability === "durable");
+const sessionV1LiveDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durability === "ephemeral");
 const coreDefinitions = Event.inventory(...sessionV1DurableDefinitions, ...SessionEvent.Definitions);
 const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Integration.Event.Definitions, ...Catalog.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
 const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...ProjectDirectories.Event.Definitions, ...Command.Event.Definitions, ...Skill.Event.Definitions, ...FileSystemWatcher.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Question.Event.Definitions, ...Form.Event.Definitions);

package/dist/event.d.ts

@@ -15,49 +15,62 @@ export type Seq = typeof Seq.Type;
 /** Durable schema version of one event type, from the event definition that committed it. */
 export declare const Version: Schema.brand<Schema.Int, "Event.Version">;
 export type Version = typeof Version.Type;
-export type Definition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
+declare const DurableEnvelope: Schema.Struct<{
+    readonly aggregateID: Schema.String;
+    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+    readonly version: Schema.brand<Schema.Int, "Event.Version">;
+}>;
+export type DurableEnvelope = typeof DurableEnvelope.Type;
+export type DurableDefinition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
     readonly type: Type;
-    readonly durable?: {
+    readonly durability: "durable";
+    readonly durable: {
         readonly version: number;
         readonly aggregate: string;
     };
     readonly data: DataSchema;
 };
+export type EphemeralDefinition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
+    readonly type: Type;
+    readonly durability: "ephemeral";
+    readonly durable?: never;
+    readonly data: DataSchema;
+};
+export type Definition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = DurableDefinition<Type, DataSchema> | EphemeralDefinition<Type, DataSchema>;
 export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>;
-export type Payload<D extends Definition = Definition> = {
+type PayloadBase<D extends Definition> = {
     readonly id: ID;
     readonly type: D["type"];
     readonly data: Data<D>;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: Seq;
-        readonly version: Version;
-    };
     readonly location?: Location.Ref;
     readonly metadata?: Record<string, unknown>;
 };
-export declare function define<const Type extends string, const Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>>(input: {
+export type Payload<D extends Definition = Definition> = D extends DurableDefinition ? PayloadBase<D> & {
+    readonly durable: DurableEnvelope;
+} : PayloadBase<D> & {
+    readonly durable?: never;
+};
+type Input<Type extends string, Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>> = {
     readonly type: Type;
     readonly durable?: {
         readonly version: number;
         readonly aggregate: string;
     };
     readonly schema: Fields;
+};
+export declare function durable<const Type extends string, const Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>>(input: Input<Type, Fields> & {
+    readonly durable: NonNullable<Input<Type, Fields>["durable"]>;
 }): 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<Type>;
-    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 durable: 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"> & {
@@ -79,14 +92,47 @@ export declare function define<const Type extends string, const Fields extends R
     }>>, never, never>;
     readonly data: Schema.Struct<Fields>;
 }> & {
-    data: Schema.Struct<Fields>;
-    durable?: {
+    type: Type;
+    durability: "durable";
+    durable: {
         readonly version: number;
         readonly aggregate: string;
-    } | undefined;
+    };
+    data: Schema.Struct<Fields>;
+};
+export declare function ephemeral<const Type extends string, const Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>>(input: Omit<Input<Type, Fields>, "durable">): 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<Type>;
+    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"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<Fields>;
+}> & {
     type: Type;
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<Fields>;
 };
 export declare function inventory<const Definitions extends ReadonlyArray<Definition>>(...definitions: Definitions): Readonly<Definitions>;
 export declare function latest(definitions: ReadonlyArray<Definition>): ReadonlyMap<string, Definition<string, Schema.Codec<unknown, unknown, never, never>>>;
 export declare function versionedType(type: string, version: number): string;
-export declare function durable<const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions): ReadonlyMap<string, Definitions[number]>;
+export declare function durableMap<const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions): ReadonlyMap<string, DurableDefinition<string, Schema.Codec<unknown, unknown, never, never>>>;

package/dist/event.js

@@ -13,20 +13,39 @@ export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(Schema.b
 export const Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("Event.Seq"));
 /** Durable schema version of one event type, from the event definition that committed it. */
 export const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("Event.Version"));
-export function define(input) {
+const DurableEnvelope = Schema.Struct({ aggregateID: Schema.String, seq: Seq, version: Version });
+export function durable(input) {
     const data = Schema.Struct(input.schema);
     return Schema.Struct({
         id: ID,
         metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
         type: Schema.Literal(input.type),
-        durable: optional(Schema.Struct({ aggregateID: Schema.String, seq: Seq, version: Version })),
+        durable: DurableEnvelope,
         location: optional(Location.Ref),
         data,
     })
         .annotate({ identifier: input.type })
         .pipe(statics(() => ({
         type: input.type,
-        ...(input.durable === undefined ? {} : { durable: input.durable }),
+        durability: "durable",
+        durable: input.durable,
+        data,
+    })));
+}
+export function ephemeral(input) {
+    const data = Schema.Struct(input.schema);
+    return Schema.Struct({
+        id: ID,
+        metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+        type: Schema.Literal(input.type),
+        location: optional(Location.Ref),
+        data,
+    })
+        .annotate({ identifier: input.type })
+        .pipe(statics(() => ({
+        type: input.type,
+        durability: "ephemeral",
+        durable: undefined,
         data,
     })));
 }
@@ -53,9 +72,9 @@ export function latest(definitions) {
 export function versionedType(type, version) {
     return `${type}.${version}`;
 }
-export function durable(definitions) {
+export function durableMap(definitions) {
     return readonlyMap(definitions.reduce((result, definition) => {
-        if (!definition.durable)
+        if (definition.durability !== "durable")
             return result;
         const key = versionedType(definition.type, definition.durable.version);
         if (result.has(key))

package/dist/filesystem-watcher.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<"file.watcher.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"> & {
@@ -40,15 +31,13 @@ export declare const Event: {
             readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
         }>;
     }> & {
+        type: "file.watcher.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly file: Schema.String;
             readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "file.watcher.updated";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -56,15 +45,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<"file.watcher.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"> & {
@@ -89,14 +69,12 @@ export declare const Event: {
             readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
         }>;
     }> & {
+        type: "file.watcher.updated";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly file: Schema.String;
             readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "file.watcher.updated";
     }];
 };

package/dist/filesystem-watcher.js

@@ -1,7 +1,7 @@
 export * as FileSystemWatcher from "./filesystem-watcher.js";
 import { Schema } from "effect";
-import { define, inventory } from "./event.js";
-const Updated = define({
+import { ephemeral, inventory } from "./event.js";
+const Updated = ephemeral({
     type: "file.watcher.updated",
     schema: {
         file: Schema.String,

package/dist/filesystem.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<"file.edited">;
-        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,14 +30,12 @@ export declare const Event: {
             readonly file: Schema.String;
         }>;
     }> & {
+        type: "file.edited";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly file: Schema.String;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "file.edited";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -54,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<"file.edited">;
-        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,14 +66,12 @@ export declare const Event: {
             readonly file: Schema.String;
         }>;
     }> & {
+        type: "file.edited";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly file: Schema.String;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "file.edited";
     }];
 };
 export interface Entry extends Schema.Schema.Type<typeof Entry> {

package/dist/filesystem.js

@@ -1,9 +1,9 @@
 export * as FileSystem from "./filesystem.js";
 import { Schema } from "effect";
 import { optional } from "./schema.js";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { NonNegativeInt, PositiveInt, RelativePath } from "./schema.js";
-const Edited = define({
+const Edited = ephemeral({
     type: "file.edited",
     schema: { file: Schema.String },
 });

package/dist/form.d.ts

@@ -534,15 +534,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<"form.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"> & {
@@ -691,6 +682,9 @@ export declare const Event: {
             }>]>;
         }>;
     }> & {
+        type: "form.created";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
                 readonly mode: Schema.Literal<"form">;
@@ -819,11 +813,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>;
             }>]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.created";
     };
     Replied: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -831,15 +820,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<"form.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"> & {
@@ -867,6 +847,9 @@ export declare const Event: {
             readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
         }>;
     }> & {
+        type: "form.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Form.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
@@ -874,11 +857,6 @@ export declare const Event: {
             readonly sessionID: Schema.String;
             readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.replied";
     };
     Cancelled: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -886,15 +864,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<"form.cancelled">;
-        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"> & {
@@ -921,17 +890,15 @@ export declare const Event: {
             readonly sessionID: Schema.String;
         }>;
     }> & {
+        type: "form.cancelled";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Form.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
             };
             readonly sessionID: Schema.String;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.cancelled";
     };
     Definitions: readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -939,15 +906,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<"form.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"> & {
@@ -1096,6 +1054,9 @@ export declare const Event: {
             }>]>;
         }>;
     }> & {
+        type: "form.created";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
                 readonly mode: Schema.Literal<"form">;
@@ -1224,26 +1185,12 @@ 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>;
             }>]>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.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<"form.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"> & {
@@ -1271,6 +1218,9 @@ export declare const Event: {
             readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
         }>;
     }> & {
+        type: "form.replied";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Form.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
@@ -1278,26 +1228,12 @@ export declare const Event: {
             readonly sessionID: Schema.String;
             readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.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<"form.cancelled">;
-        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"> & {
@@ -1324,16 +1260,14 @@ export declare const Event: {
             readonly sessionID: Schema.String;
         }>;
     }> & {
+        type: "form.cancelled";
+        durability: "ephemeral";
+        durable: undefined;
         data: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Form.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
             };
             readonly sessionID: Schema.String;
         }>;
-        durable?: {
-            readonly version: number;
-            readonly aggregate: string;
-        } | undefined;
-        type: "form.cancelled";
     }];
 };

package/dist/form.js

@@ -1,6 +1,6 @@
 export * as Form from "./form.js";
 import { Schema } from "effect";
-import { define, inventory } from "./event.js";
+import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, optional, statics } from "./schema.js";
 const IDSchema = Schema.String.check(Schema.isStartsWith("frm_")).pipe(Schema.brand("Form.ID"));
@@ -106,7 +106,7 @@ export const State = Schema.Union([
 export const Reply = Schema.Struct({
     answer: Answer,
 }).annotate({ identifier: "Form.Reply" });
-const Created = define({ type: "form.created", schema: { form: Info } });
-const Replied = define({ type: "form.replied", schema: { id: ID, sessionID: Schema.String, answer: Answer } });
-const Cancelled = define({ type: "form.cancelled", schema: { id: ID, sessionID: Schema.String } });
+const Created = ephemeral({ type: "form.created", schema: { form: Info } });
+const Replied = ephemeral({ type: "form.replied", schema: { id: ID, sessionID: Schema.String, answer: Answer } });
+const Cancelled = ephemeral({ type: "form.cancelled", schema: { id: ID, sessionID: Schema.String } });
 export const Event = { Created, Replied, Cancelled, Definitions: inventory(Created, Replied, Cancelled) };