@opencode-ai/schema 0.0.0-next-14659

package/dist/workspace-event.d.ts

@@ -0,0 +1,307 @@
+export * as WorkspaceEvent from "./workspace-event.js";
+import { Schema } from "effect";
+export declare const ConnectionStatus: Schema.Struct<{
+    readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+    };
+    readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
+}>;
+export interface ConnectionStatus extends Schema.Schema.Type<typeof ConnectionStatus> {
+}
+export declare const Ready: 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<"workspace.ready">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly name: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.ready";
+};
+export declare const Failed: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"workspace.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly message: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly message: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.failed";
+};
+export declare const Status: 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<"workspace.status">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.status";
+};
+export declare const Definitions: readonly [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<"workspace.ready">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly name: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.ready";
+}, 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<"workspace.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly message: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly message: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.failed";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"workspace.status">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly workspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["connected", "connecting", "disconnected", "error"]>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "workspace.status";
+}];

package/dist/workspace-event.js

@@ -0,0 +1,25 @@
+export * as WorkspaceEvent from "./workspace-event.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+import { WorkspaceID } from "./workspace-id.js";
+export const ConnectionStatus = Schema.Struct({
+    workspaceID: WorkspaceID,
+    status: Schema.Literals(["connected", "connecting", "disconnected", "error"]),
+}).annotate({ identifier: "WorkspaceEvent.ConnectionStatus" });
+export const Ready = Event.define({
+    type: "workspace.ready",
+    schema: {
+        name: Schema.String,
+    },
+});
+export const Failed = Event.define({
+    type: "workspace.failed",
+    schema: {
+        message: Schema.String,
+    },
+});
+export const Status = Event.define({
+    type: "workspace.status",
+    schema: ConnectionStatus.fields,
+});
+export const Definitions = Event.inventory(Ready, Failed, Status);

package/dist/workspace-id.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+export declare const WorkspaceID: Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+    create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+};
+export type WorkspaceID = typeof WorkspaceID.Type;

package/dist/workspace-id.js

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+import { ascending } from "./identifier.js";
+import { statics } from "./schema.js";
+export const WorkspaceID = Schema.String.check(Schema.isStartsWith("wrk")).pipe(Schema.brand("WorkspaceV2.ID"), statics((schema) => {
+    const create = () => schema.make("wrk_" + ascending());
+    return {
+        ascending: (id) => {
+            if (!id)
+                return create();
+            if (!id.startsWith("wrk"))
+                throw new Error(`ID ${id} does not start with wrk`);
+            return schema.make(id);
+        },
+        create,
+    };
+}));

package/dist/workspace.d.ts

@@ -0,0 +1,9 @@
+export * as Workspace from "./workspace.js";
+import { WorkspaceEvent } from "./workspace-event.js";
+import { WorkspaceID } from "./workspace-id.js";
+export declare const ID: import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+    create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+};
+export type ID = WorkspaceID;
+export declare const Event: typeof WorkspaceEvent;

package/dist/workspace.js

@@ -0,0 +1,5 @@
+export * as Workspace from "./workspace.js";
+import { WorkspaceEvent } from "./workspace-event.js";
+import { WorkspaceID } from "./workspace-id.js";
+export const ID = WorkspaceID;
+export const Event = WorkspaceEvent;

package/dist/worktree-event.d.ts

@@ -0,0 +1,193 @@
+export * as WorktreeEvent from "./worktree-event.js";
+import { Schema } from "effect";
+export declare const Ready: 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<"worktree.ready">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly name: Schema.String;
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "worktree.ready";
+};
+export declare const Failed: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"worktree.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly message: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly message: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "worktree.failed";
+};
+export declare const Definitions: readonly [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<"worktree.ready">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly name: Schema.String;
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "worktree.ready";
+}, 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<"worktree.failed">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, 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"> & {
+            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<{
+        readonly message: Schema.String;
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly message: Schema.String;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "worktree.failed";
+}];

package/dist/worktree-event.js

@@ -0,0 +1,18 @@
+export * as WorktreeEvent from "./worktree-event.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Event } from "./event.js";
+export const Ready = Event.define({
+    type: "worktree.ready",
+    schema: {
+        name: Schema.String,
+        branch: optional(Schema.String),
+    },
+});
+export const Failed = Event.define({
+    type: "worktree.failed",
+    schema: {
+        message: Schema.String,
+    },
+});
+export const Definitions = Event.inventory(Ready, Failed);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/schema",
+  "version": "0.0.0-next-14659",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/schema"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "effect": "4.0.0-beta.83"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "typescript": "5.8.2"
+  }
+}