@opencode/schema 0.0.0-reserved → 2.0.0

package/dist/session-revert.js

@@ -0,0 +1,63 @@
+import { Schema, SchemaTransformation } from "effect";
+import { FileDiff } from "./file-diff.js";
+import { optional } from "./schema.js";
+import { SessionMessage } from "./session-message.js";
+import { Snapshot } from "./snapshot.js";
+export const Revert = Schema.Struct({
+    messageID: SessionMessage.ID,
+    /** Legacy V1 compatibility state. */
+    partID: Schema.String.pipe(optional),
+    snapshot: Snapshot.ID.pipe(optional),
+    files: Schema.Array(FileDiff.Info).pipe(optional),
+}).annotate({ identifier: "Session.Revert" });
+const FileDiffV1 = Schema.Struct({
+    path: Schema.String,
+    status: Schema.Literals(["added", "modified", "deleted"]),
+    additions: Schema.Finite,
+    deletions: Schema.Finite,
+    patch: Schema.String,
+});
+export const RevertV1 = Schema.Struct({
+    messageID: SessionMessage.ID,
+    partID: Schema.String.pipe(optional),
+    snapshot: Schema.String.pipe(optional),
+    diff: Schema.String.pipe(optional),
+    files: Schema.Array(FileDiffV1).pipe(optional),
+}).annotate({ identifier: "Session.RevertV1" });
+const PersistedCurrent = Revert.pipe(Schema.decodeTo(Schema.Struct({ source: Schema.tag("current"), revert: Schema.toType(Revert) }), SchemaTransformation.transform({
+    decode: (revert) => ({
+        source: "current",
+        revert,
+    }),
+    encode: (value) => value.revert,
+})));
+const PersistedLegacy = RevertV1.pipe(Schema.decodeTo(Schema.Struct({ source: Schema.tag("legacy"), revert: Schema.toType(RevertV1) }), SchemaTransformation.transform({
+    decode: (revert) => ({
+        source: "legacy",
+        revert,
+    }),
+    encode: (value) => value.revert,
+})));
+/** Storage decoder for revert state written before FileDiff became canonical. */
+export const PersistedRevert = Schema.Union([PersistedCurrent, PersistedLegacy]).pipe(Schema.toTaggedUnion("source"), Schema.decodeTo(Schema.toType(Revert), SchemaTransformation.transform({
+    decode: (persisted) => {
+        if (persisted.source === "current")
+            return persisted.revert;
+        return Revert.make({
+            messageID: persisted.revert.messageID,
+            partID: persisted.revert.partID,
+            snapshot: persisted.revert.snapshot ? Snapshot.ID.make(persisted.revert.snapshot) : undefined,
+            files: persisted.revert.files?.map((file) => ({
+                file: file.path,
+                status: file.status,
+                additions: file.additions,
+                deletions: file.deletions,
+                patch: file.patch,
+            })),
+        });
+    },
+    encode: (revert) => ({
+        source: "current",
+        revert,
+    }),
+})), Schema.annotate({ identifier: "Session.Revert.Persisted" }));

package/dist/session-stats.d.ts

@@ -0,0 +1,186 @@
+export * as SessionStats from "./session-stats.js";
+import { Schema } from "effect";
+export declare const Activity: Schema.Struct<{
+    readonly date: Schema.String;
+    readonly steps: Schema.Int;
+}>;
+export type Activity = typeof Activity.Type;
+export declare const ModelUsage: Schema.Struct<{
+    readonly model: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    };
+    readonly steps: Schema.Int;
+    readonly tokens: Schema.Struct<{
+        readonly input: Schema.Finite;
+        readonly output: Schema.Finite;
+        readonly reasoning: Schema.Finite;
+        readonly cache: Schema.Struct<{
+            readonly read: Schema.Finite;
+            readonly write: Schema.Finite;
+        }>;
+    }>;
+    readonly cost: Schema.brand<Schema.Finite, "Money.USD"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USD">;
+    };
+}>;
+export type ModelUsage = typeof ModelUsage.Type;
+export declare const ToolUsage: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly calls: Schema.Int;
+    readonly succeeded: Schema.Int;
+    readonly failed: Schema.Int;
+    readonly unfinished: Schema.Int;
+    readonly durationP50: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+}>;
+export type ToolUsage = typeof ToolUsage.Type;
+export declare const ToolMode: Schema.Literals<readonly ["none", "summary", "detail"]>;
+export type ToolMode = typeof ToolMode.Type;
+export declare const ToolTotals: Schema.Struct<{
+    readonly calls: Schema.Int;
+    readonly succeeded: Schema.Int;
+    readonly failed: Schema.Int;
+    readonly unfinished: Schema.Int;
+}>;
+export type ToolTotals = typeof ToolTotals.Type;
+export declare const Tools: Schema.Union<readonly [Schema.Struct<{
+    readonly mode: Schema.Literal<"none">;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"summary">;
+    readonly totals: Schema.Struct<{
+        readonly calls: Schema.Int;
+        readonly succeeded: Schema.Int;
+        readonly failed: Schema.Int;
+        readonly unfinished: Schema.Int;
+    }>;
+}>, Schema.Struct<{
+    readonly mode: Schema.Literal<"detail">;
+    readonly totals: Schema.Struct<{
+        readonly calls: Schema.Int;
+        readonly succeeded: Schema.Int;
+        readonly failed: Schema.Int;
+        readonly unfinished: Schema.Int;
+    }>;
+    readonly usage: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly calls: Schema.Int;
+        readonly succeeded: Schema.Int;
+        readonly failed: Schema.Int;
+        readonly unfinished: Schema.Int;
+        readonly durationP50: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    }>>;
+}>]>;
+export type Tools = typeof Tools.Type;
+export declare const Info: Schema.Struct<{
+    readonly range: Schema.Struct<{
+        readonly from: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly to: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    }>;
+    readonly sessions: Schema.Int;
+    readonly subagents: Schema.Int;
+    readonly prompts: Schema.Int;
+    readonly steps: Schema.Int;
+    readonly tokens: Schema.Struct<{
+        readonly input: Schema.Finite;
+        readonly output: Schema.Finite;
+        readonly reasoning: Schema.Finite;
+        readonly cache: Schema.Struct<{
+            readonly read: Schema.Finite;
+            readonly write: Schema.Finite;
+        }>;
+    }>;
+    readonly cost: Schema.brand<Schema.Finite, "Money.USD"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USD">;
+    };
+    readonly tools: Schema.Union<readonly [Schema.Struct<{
+        readonly mode: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"summary">;
+        readonly totals: Schema.Struct<{
+            readonly calls: Schema.Int;
+            readonly succeeded: Schema.Int;
+            readonly failed: Schema.Int;
+            readonly unfinished: Schema.Int;
+        }>;
+    }>, Schema.Struct<{
+        readonly mode: Schema.Literal<"detail">;
+        readonly totals: Schema.Struct<{
+            readonly calls: Schema.Int;
+            readonly succeeded: Schema.Int;
+            readonly failed: Schema.Int;
+            readonly unfinished: Schema.Int;
+        }>;
+        readonly usage: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly calls: Schema.Int;
+            readonly succeeded: Schema.Int;
+            readonly failed: Schema.Int;
+            readonly unfinished: Schema.Int;
+            readonly durationP50: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        }>>;
+    }>]>;
+    readonly activeDays: Schema.Int;
+    readonly streak: Schema.Int;
+    readonly activity: Schema.$Array<Schema.Struct<{
+        readonly date: Schema.String;
+        readonly steps: Schema.Int;
+    }>>;
+    readonly models: Schema.$Array<Schema.Struct<{
+        readonly model: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        };
+        readonly steps: Schema.Int;
+        readonly tokens: Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly reasoning: Schema.Finite;
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.Finite;
+                readonly write: Schema.Finite;
+            }>;
+        }>;
+        readonly cost: Schema.brand<Schema.Finite, "Money.USD"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USD">;
+        };
+    }>>;
+}>;
+export type Info = typeof Info.Type;

package/dist/session-stats.js

@@ -0,0 +1,53 @@
+export * as SessionStats from "./session-stats.js";
+import { Schema } from "effect";
+import { Model } from "./model.js";
+import { Money } from "./money.js";
+import { DateTimeUtcFromMillis, NonNegativeInt, optional } from "./schema.js";
+import { TokenUsage } from "./token-usage.js";
+export const Activity = Schema.Struct({
+    date: Schema.String,
+    steps: NonNegativeInt,
+}).annotate({ identifier: "SessionStats.Activity" });
+export const ModelUsage = Schema.Struct({
+    model: Model.Ref,
+    steps: NonNegativeInt,
+    tokens: TokenUsage.Info,
+    cost: Money.USD,
+}).annotate({ identifier: "SessionStats.ModelUsage" });
+export const ToolUsage = Schema.Struct({
+    name: Schema.String,
+    calls: NonNegativeInt,
+    succeeded: NonNegativeInt,
+    failed: NonNegativeInt,
+    unfinished: NonNegativeInt,
+    durationP50: Schema.Finite.pipe(optional),
+}).annotate({ identifier: "SessionStats.ToolUsage" });
+export const ToolMode = Schema.Literals(["none", "summary", "detail"]);
+export const ToolTotals = Schema.Struct({
+    calls: NonNegativeInt,
+    succeeded: NonNegativeInt,
+    failed: NonNegativeInt,
+    unfinished: NonNegativeInt,
+}).annotate({ identifier: "SessionStats.ToolTotals" });
+export const Tools = Schema.Union([
+    Schema.Struct({ mode: Schema.Literal("none") }),
+    Schema.Struct({ mode: Schema.Literal("summary"), totals: ToolTotals }),
+    Schema.Struct({ mode: Schema.Literal("detail"), totals: ToolTotals, usage: Schema.Array(ToolUsage) }),
+]).annotate({ identifier: "SessionStats.Tools" });
+export const Info = Schema.Struct({
+    range: Schema.Struct({
+        from: DateTimeUtcFromMillis,
+        to: DateTimeUtcFromMillis,
+    }),
+    sessions: NonNegativeInt,
+    subagents: NonNegativeInt,
+    prompts: NonNegativeInt,
+    steps: NonNegativeInt,
+    tokens: TokenUsage.Info,
+    cost: Money.USD,
+    tools: Tools,
+    activeDays: NonNegativeInt,
+    streak: NonNegativeInt,
+    activity: Schema.Array(Activity),
+    models: Schema.Array(ModelUsage),
+}).annotate({ identifier: "SessionStats.Info" });

package/dist/session-status-event.d.ts

@@ -0,0 +1,299 @@
+export * as SessionStatusEvent from "./session-status-event.js";
+import { Schema } from "effect";
+export declare const Info: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"idle">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"retry">;
+    readonly attempt: Schema.Int;
+    readonly message: Schema.String;
+    readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reason: Schema.String;
+        readonly provider: Schema.String;
+        readonly title: Schema.String;
+        readonly message: Schema.String;
+        readonly label: Schema.String;
+        readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reason: Schema.String;
+        readonly provider: Schema.String;
+        readonly title: Schema.String;
+        readonly message: Schema.String;
+        readonly label: Schema.String;
+        readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly next: Schema.Int;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"busy">;
+}>]>;
+export type Info = Schema.Schema.Type<typeof Info>;
+export declare const Status: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"session.status">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly status: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"idle">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"retry">;
+            readonly attempt: Schema.Int;
+            readonly message: Schema.String;
+            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly next: Schema.Int;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"busy">;
+        }>]>;
+    }>;
+}> & {
+    type: "session.status";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly status: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"idle">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"retry">;
+            readonly attempt: Schema.Int;
+            readonly message: Schema.String;
+            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly next: Schema.Int;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"busy">;
+        }>]>;
+    }>;
+};
+export declare const Idle: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"session.idle">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.idle";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"session.status">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly status: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"idle">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"retry">;
+            readonly attempt: Schema.Int;
+            readonly message: Schema.String;
+            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly next: Schema.Int;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"busy">;
+        }>]>;
+    }>;
+}> & {
+    type: "session.status";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly status: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"idle">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"retry">;
+            readonly attempt: Schema.Int;
+            readonly message: Schema.String;
+            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly reason: Schema.String;
+                readonly provider: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly label: Schema.String;
+                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>>, never, never>;
+            readonly next: Schema.Int;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"busy">;
+        }>]>;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"session.idle">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.idle";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}];

package/dist/session-status-event.js

@@ -0,0 +1,45 @@
+export * as SessionStatusEvent from "./session-status-event.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Event } from "./event.js";
+import { NonNegativeInt } from "./schema.js";
+import { SessionID } from "./session-id.js";
+export const Info = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("idle"),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("retry"),
+        attempt: NonNegativeInt,
+        message: Schema.String,
+        action: optional(Schema.Struct({
+            reason: Schema.String,
+            provider: Schema.String,
+            title: Schema.String,
+            message: Schema.String,
+            label: Schema.String,
+            link: optional(Schema.String),
+        })),
+        next: NonNegativeInt,
+    }),
+    Schema.Struct({
+        type: Schema.Literal("busy"),
+    }),
+]).annotate({ identifier: "SessionStatus" });
+export const Status = Event.ephemeral({
+    type: "session.status",
+    // The bare SessionStatus identifier belongs to the status union above.
+    identifier: "SessionStatusUpdated",
+    schema: {
+        sessionID: SessionID,
+        status: Info,
+    },
+});
+// deprecated
+export const Idle = Event.ephemeral({
+    type: "session.idle",
+    schema: {
+        sessionID: SessionID,
+    },
+});
+export const Definitions = Event.inventory(Status, Idle);