npm - @opencode-ai/schema - Versions diffs - 0.0.0-dev-18199 → 0.0.0-dev-18202 - Mend

@opencode-ai/schema 0.0.0-dev-18199 → 0.0.0-dev-18202

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/event-manifest.d.ts +288 -0
package/dist/event-manifest.js +2 -1
package/dist/index.d.ts +1 -0
package/dist/index.js +1 -0
package/dist/persistent-pty.d.ts +530 -0
package/dist/persistent-pty.js +34 -0
package/package.json +1 -1

package/dist/event-manifest.d.ts CHANGED Viewed

@@ -4471,6 +4471,150 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
         };
     }>;
+}, 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<"persistent-pty.added">;
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}, 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<"persistent-pty.removed">;
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -10035,6 +10179,150 @@ export declare const Definitions: readonly [Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
         };
     }>;
+}, 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<"persistent-pty.added">;
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}, 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<"persistent-pty.removed">;
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/event-manifest.js CHANGED Viewed

@@ -16,6 +16,7 @@ import { LspEvent } from "./lsp-event.js";
 import { McpEvent } from "./mcp-event.js";
 import { ModelsDev } from "./models-dev.js";
 import { Permission } from "./permission.js";
+import { PersistentPty } from "./persistent-pty.js";
 import { Plugin } from "./plugin.js";
 import { Project } from "./project.js";
 import { Worktree } from "./worktree.js";
@@ -34,7 +35,7 @@ import { WorktreeEvent } from "./worktree-event.js";
 import { WebSearch } from "./websearch.js";
 const coreDefinitions = Event.inventory(...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, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
+const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...PersistentPty.Event.Definitions, ...Shell.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
 export const ServerDefinitions = Event.inventory(...foundationDefinitions, ...featureDefinitions,
 // Current events the TUI consumes from the public stream.
 ...SessionStatusEvent.Definitions, ...TuiEvent.Definitions, ...InstallationEvent.Definitions, ...VcsEvent.Definitions, McpEvent.StatusChanged, McpEvent.ResourcesChanged);

package/dist/index.d.ts CHANGED Viewed

@@ -31,6 +31,7 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { TokenUsage } from "./token-usage.js";
 export { Pty } from "./pty.js";
+export { PersistentPty } from "./persistent-pty.js";
 export { PtyTicket } from "./pty-ticket.js";
 export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";

package/dist/index.js CHANGED Viewed

@@ -31,6 +31,7 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { TokenUsage } from "./token-usage.js";
 export { Pty } from "./pty.js";
+export { PersistentPty } from "./persistent-pty.js";
 export { PtyTicket } from "./pty-ticket.js";
 export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";

package/dist/persistent-pty.d.ts ADDED Viewed

@@ -0,0 +1,530 @@
+export * as PersistentPty from "./persistent-pty.js";
+import { Schema } from "effect";
+export declare const Info: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+    readonly size: Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly head: Schema.Int;
+        readonly tail: Schema.Int;
+    }>;
+    readonly id: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+    readonly title: Schema.String;
+    readonly command: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["running", "exited"]>;
+    readonly pid: Schema.Int;
+    readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const CreateInput: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.String;
+    readonly title: Schema.String;
+    readonly env: Schema.$Record<Schema.String, Schema.String>;
+    readonly size: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>>, never, never>;
+}>;
+export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+export declare const UpdateInput: Schema.Struct<{
+    readonly attachmentID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly size: Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>;
+}>;
+export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {
+}
+export declare const Snapshot: Schema.Struct<{
+    readonly info: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+        readonly size: Schema.Struct<{
+            readonly cols: Schema.Int;
+            readonly rows: Schema.Int;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly head: Schema.Int;
+            readonly tail: Schema.Int;
+        }>;
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+    readonly text: Schema.String;
+    readonly checkpoint: Schema.Uint8Array;
+    readonly cursor: Schema.Struct<{
+        readonly x: Schema.Int;
+        readonly y: Schema.Int;
+    }>;
+}>;
+export interface Snapshot extends Schema.Schema.Type<typeof Snapshot> {
+}
+export declare const Added: 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<"persistent-pty.added">;
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+};
+export declare const Removed: 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<"persistent-pty.removed">;
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+};
+export declare const Event: {
+    Added: 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<"persistent-pty.added">;
+        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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }> & {
+        type: "persistent-pty.added";
+        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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    };
+    Removed: 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<"persistent-pty.removed">;
+        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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }> & {
+        type: "persistent-pty.removed";
+        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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    };
+    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<"persistent-pty.added">;
+        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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }> & {
+        type: "persistent-pty.added";
+        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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }, 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<"persistent-pty.removed">;
+        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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }> & {
+        type: "persistent-pty.removed";
+        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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }];
+};

package/dist/persistent-pty.js ADDED Viewed

@@ -0,0 +1,34 @@
+export * as PersistentPty from "./persistent-pty.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { Pty } from "./pty.js";
+import { NonNegativeInt, PositiveInt, optional } from "./schema.js";
+import { Session } from "./session.js";
+export const Info = Schema.Struct({
+    ...Pty.Info.fields,
+    sessionID: Session.ID,
+    foregroundProcess: Schema.NullOr(Schema.String),
+    size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+    output: Schema.Struct({ head: NonNegativeInt, tail: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Info" });
+export const CreateInput = Schema.Struct({
+    command: Schema.String,
+    args: Schema.Array(Schema.String),
+    cwd: Schema.String,
+    title: Schema.String,
+    env: Schema.Record(Schema.String, Schema.String),
+    size: optional(Schema.Struct({ cols: PositiveInt, rows: PositiveInt })),
+}).annotate({ identifier: "PersistentPty.CreateInput" });
+export const UpdateInput = Schema.Struct({
+    attachmentID: optional(Schema.String),
+    size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+}).annotate({ identifier: "PersistentPty.UpdateInput" });
+export const Snapshot = Schema.Struct({
+    info: Info,
+    text: Schema.String,
+    checkpoint: Schema.Uint8Array,
+    cursor: Schema.Struct({ x: NonNegativeInt, y: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Snapshot" });
+export const Added = ephemeral({ type: "persistent-pty.added", schema: { sessionID: Session.ID, terminal: Info } });
+export const Removed = ephemeral({ type: "persistent-pty.removed", schema: { sessionID: Session.ID, ptyID: Pty.ID } });
+export const Event = { Added, Removed, Definitions: inventory(Added, Removed) };

package/package.json CHANGED Viewed

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