@opencode-ai/schema 0.0.0-dev-17471

package/dist/v1/session.js

@@ -0,0 +1,535 @@
+export * as SessionV1 from "./session.js";
+import { Effect, Schema, Types } from "effect";
+import { durable, ephemeral, inventory } from "../event.js";
+import { Project } from "../project.js";
+import { Provider } from "../provider.js";
+import { Model } from "../model.js";
+import { NonNegativeInt, optional, statics } from "../schema.js";
+import { ascending } from "../identifier.js";
+import { SessionID } from "../session-id.js";
+import { WorkspaceID } from "../workspace-id.js";
+import { PermissionV1 } from "./permission.js";
+import { FileDiff } from "../file-diff.js";
+const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(Schema.brand("SessionV1.MessageID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "msg_" + ascending()) })));
+export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(Schema.brand("SessionV1.PartID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "prt_" + ascending()) })));
+const namedError = (name, fields) => {
+    const schema = Schema.Struct({ name: Schema.Literal(name), data: Schema.Struct(fields) }).annotate({
+        identifier: name,
+    });
+    return { Schema: schema, EffectSchema: schema };
+};
+export const OutputLengthError = namedError("MessageOutputLengthError", {});
+export const AuthError = namedError("ProviderAuthError", {
+    providerID: Schema.String,
+    message: Schema.String,
+});
+export const AbortedError = namedError("MessageAbortedError", { message: Schema.String });
+export const StructuredOutputError = namedError("StructuredOutputError", {
+    message: Schema.String,
+    retries: NonNegativeInt,
+});
+export const APIError = namedError("APIError", {
+    message: Schema.String,
+    statusCode: Schema.optional(NonNegativeInt),
+    isRetryable: Schema.Boolean,
+    responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    responseBody: Schema.optional(Schema.String),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+});
+export const ContextOverflowError = namedError("ContextOverflowError", {
+    message: Schema.String,
+    responseBody: Schema.optional(Schema.String),
+});
+export const ContentFilterError = namedError("ContentFilterError", {
+    message: Schema.String,
+});
+export class OutputFormatText extends Schema.Class("OutputFormatText")({
+    type: Schema.Literal("text"),
+}) {
+}
+export class OutputFormatJsonSchema extends Schema.Class("OutputFormatJsonSchema")({
+    type: Schema.Literal("json_schema"),
+    schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "SessionV1.JSONSchema" }),
+    retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
+}) {
+}
+export const Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({
+    discriminator: "type",
+    identifier: "SessionV1.OutputFormat",
+});
+const partBase = {
+    id: PartID,
+    sessionID: SessionID,
+    messageID: MessageID,
+};
+export const SnapshotPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("snapshot"),
+    snapshot: Schema.String,
+}).annotate({ identifier: "SessionV1.SnapshotPart" });
+export const PatchPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("patch"),
+    hash: Schema.String,
+    files: Schema.Array(Schema.String),
+}).annotate({ identifier: "SessionV1.PatchPart" });
+export const TextPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    synthetic: Schema.optional(Schema.Boolean),
+    ignored: Schema.optional(Schema.Boolean),
+    time: Schema.optional(Schema.Struct({
+        start: NonNegativeInt,
+        end: Schema.optional(NonNegativeInt),
+    })),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "SessionV1.TextPart" });
+export const ReasoningPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("reasoning"),
+    text: Schema.String,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+    time: Schema.Struct({
+        start: NonNegativeInt,
+        end: Schema.optional(NonNegativeInt),
+    }),
+}).annotate({ identifier: "SessionV1.ReasoningPart" });
+const filePartSourceBase = {
+    text: Schema.Struct({
+        value: Schema.String,
+        start: Schema.Finite,
+        end: Schema.Finite,
+    }).annotate({ identifier: "SessionV1.FilePartSourceText" }),
+};
+export const Range = Schema.Struct({
+    start: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
+    end: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
+}).annotate({ identifier: "SessionV1.Range" });
+export const FileSource = Schema.Struct({
+    ...filePartSourceBase,
+    type: Schema.Literal("file"),
+    path: Schema.String,
+}).annotate({ identifier: "SessionV1.FileSource" });
+export const SymbolSource = Schema.Struct({
+    ...filePartSourceBase,
+    type: Schema.Literal("symbol"),
+    path: Schema.String,
+    range: Range,
+    name: Schema.String,
+    kind: NonNegativeInt,
+}).annotate({ identifier: "SessionV1.SymbolSource" });
+export const ResourceSource = Schema.Struct({
+    ...filePartSourceBase,
+    type: Schema.Literal("resource"),
+    clientName: Schema.String,
+    uri: Schema.String,
+}).annotate({ identifier: "SessionV1.ResourceSource" });
+export const FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({
+    discriminator: "type",
+    identifier: "SessionV1.FilePartSource",
+});
+export const FilePart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("file"),
+    mime: Schema.String,
+    filename: Schema.optional(Schema.String),
+    url: Schema.String,
+    source: Schema.optional(FilePartSource),
+}).annotate({ identifier: "SessionV1.FilePart" });
+export const AgentPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("agent"),
+    name: Schema.String,
+    source: Schema.optional(Schema.Struct({
+        value: Schema.String,
+        start: NonNegativeInt,
+        end: NonNegativeInt,
+    })),
+}).annotate({ identifier: "SessionV1.AgentPart" });
+export const CompactionPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("compaction"),
+    auto: Schema.Boolean,
+    overflow: Schema.optional(Schema.Boolean),
+    tail_start_id: Schema.optional(MessageID),
+}).annotate({ identifier: "SessionV1.CompactionPart" });
+export const SubtaskPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("subtask"),
+    prompt: Schema.String,
+    description: Schema.String,
+    agent: Schema.String,
+    model: Schema.optional(Schema.Struct({
+        providerID: Provider.ID,
+        modelID: Model.ID,
+    })),
+    command: Schema.optional(Schema.String),
+}).annotate({ identifier: "SessionV1.SubtaskPart" });
+export const RetryPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("retry"),
+    attempt: NonNegativeInt,
+    error: APIError.EffectSchema,
+    time: Schema.Struct({
+        created: NonNegativeInt,
+    }),
+}).annotate({ identifier: "SessionV1.RetryPart" });
+export const StepStartPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("step-start"),
+    snapshot: Schema.optional(Schema.String),
+}).annotate({ identifier: "SessionV1.StepStartPart" });
+export const StepFinishPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("step-finish"),
+    reason: Schema.String,
+    snapshot: Schema.optional(Schema.String),
+    cost: Schema.Finite,
+    tokens: Schema.Struct({
+        total: Schema.optional(Schema.Finite),
+        input: Schema.Finite,
+        output: Schema.Finite,
+        reasoning: Schema.Finite,
+        cache: Schema.Struct({
+            read: Schema.Finite,
+            write: Schema.Finite,
+        }),
+    }),
+}).annotate({ identifier: "SessionV1.StepFinishPart" });
+export const ToolStatePending = Schema.Struct({
+    status: Schema.Literal("pending"),
+    input: Schema.Record(Schema.String, Schema.Any),
+    raw: Schema.String,
+}).annotate({ identifier: "SessionV1.ToolStatePending" });
+export const ToolStateRunning = Schema.Struct({
+    status: Schema.Literal("running"),
+    input: Schema.Record(Schema.String, Schema.Any),
+    title: Schema.optional(Schema.String),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+    time: Schema.Struct({
+        start: NonNegativeInt,
+    }),
+}).annotate({ identifier: "SessionV1.ToolStateRunning" });
+export const ToolStateCompleted = Schema.Struct({
+    status: Schema.Literal("completed"),
+    input: Schema.Record(Schema.String, Schema.Any),
+    output: Schema.String,
+    title: Schema.String,
+    metadata: Schema.Record(Schema.String, Schema.Any),
+    time: Schema.Struct({
+        start: NonNegativeInt,
+        end: NonNegativeInt,
+        compacted: Schema.optional(NonNegativeInt),
+    }),
+    attachments: Schema.optional(Schema.Array(FilePart)),
+}).annotate({ identifier: "SessionV1.ToolStateCompleted" });
+export const ToolStateError = Schema.Struct({
+    status: Schema.Literal("error"),
+    input: Schema.Record(Schema.String, Schema.Any),
+    error: Schema.String,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+    time: Schema.Struct({
+        start: NonNegativeInt,
+        end: NonNegativeInt,
+    }),
+}).annotate({ identifier: "SessionV1.ToolStateError" });
+export const ToolState = Schema.Union([
+    ToolStatePending,
+    ToolStateRunning,
+    ToolStateCompleted,
+    ToolStateError,
+]).annotate({
+    discriminator: "status",
+    identifier: "SessionV1.ToolState",
+});
+export const ToolPart = Schema.Struct({
+    ...partBase,
+    type: Schema.Literal("tool"),
+    callID: Schema.String,
+    tool: Schema.String,
+    state: ToolState,
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "SessionV1.ToolPart" });
+const messageBase = {
+    id: MessageID,
+    sessionID: partBase.sessionID,
+};
+export const User = Schema.Struct({
+    ...messageBase,
+    role: Schema.Literal("user"),
+    time: Schema.Struct({
+        created: Timestamp,
+    }),
+    format: Schema.optional(Format),
+    summary: Schema.optional(Schema.Struct({
+        title: Schema.optional(Schema.String),
+        body: Schema.optional(Schema.String),
+        diffs: Schema.Array(FileDiff.LegacyInfo),
+    })),
+    agent: Schema.String,
+    model: Schema.Struct({
+        providerID: Provider.ID,
+        modelID: Model.ID,
+        variant: Schema.optional(Schema.String),
+    }),
+    system: Schema.optional(Schema.String),
+    tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+}).annotate({ identifier: "SessionV1.UserMessage" });
+export const Part = Schema.Union([
+    TextPart,
+    SubtaskPart,
+    ReasoningPart,
+    FilePart,
+    ToolPart,
+    StepStartPart,
+    StepFinishPart,
+    SnapshotPart,
+    PatchPart,
+    AgentPart,
+    RetryPart,
+    CompactionPart,
+]).annotate({ discriminator: "type", identifier: "SessionV1.Part" });
+const AssistantErrorSchema = Schema.Union([
+    AuthError.EffectSchema,
+    namedError("UnknownError", { message: Schema.String, ref: Schema.optional(Schema.String) }).EffectSchema,
+    OutputLengthError.EffectSchema,
+    AbortedError.EffectSchema,
+    StructuredOutputError.EffectSchema,
+    ContextOverflowError.EffectSchema,
+    ContentFilterError.EffectSchema,
+    APIError.EffectSchema,
+]).annotate({ discriminator: "name" });
+export const TextPartInput = Schema.Struct({
+    id: Schema.optional(PartID),
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    synthetic: Schema.optional(Schema.Boolean),
+    ignored: Schema.optional(Schema.Boolean),
+    time: Schema.optional(Schema.Struct({
+        start: NonNegativeInt,
+        end: Schema.optional(NonNegativeInt),
+    })),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "SessionV1.TextPartInput" });
+export const FilePartInput = Schema.Struct({
+    id: Schema.optional(PartID),
+    type: Schema.Literal("file"),
+    mime: Schema.String,
+    filename: Schema.optional(Schema.String),
+    url: Schema.String,
+    source: Schema.optional(FilePartSource),
+}).annotate({ identifier: "SessionV1.FilePartInput" });
+export const AgentPartInput = Schema.Struct({
+    id: Schema.optional(PartID),
+    type: Schema.Literal("agent"),
+    name: Schema.String,
+    source: Schema.optional(Schema.Struct({
+        value: Schema.String,
+        start: NonNegativeInt,
+        end: NonNegativeInt,
+    })),
+}).annotate({ identifier: "SessionV1.AgentPartInput" });
+export const SubtaskPartInput = Schema.Struct({
+    id: Schema.optional(PartID),
+    type: Schema.Literal("subtask"),
+    prompt: Schema.String,
+    description: Schema.String,
+    agent: Schema.String,
+    model: Schema.optional(Schema.Struct({
+        providerID: Provider.ID,
+        modelID: Model.ID,
+    })),
+    command: Schema.optional(Schema.String),
+}).annotate({ identifier: "SessionV1.SubtaskPartInput" });
+export const Assistant = Schema.Struct({
+    ...messageBase,
+    role: Schema.Literal("assistant"),
+    time: Schema.Struct({
+        created: NonNegativeInt,
+        completed: Schema.optional(NonNegativeInt),
+    }),
+    error: Schema.optional(AssistantErrorSchema),
+    parentID: MessageID,
+    modelID: Model.ID,
+    providerID: Provider.ID,
+    mode: Schema.String,
+    agent: Schema.String,
+    path: Schema.Struct({
+        cwd: Schema.String,
+        root: Schema.String,
+    }),
+    summary: Schema.optional(Schema.Boolean),
+    cost: Schema.Finite,
+    tokens: Schema.Struct({
+        total: Schema.optional(Schema.Finite),
+        input: Schema.Finite,
+        output: Schema.Finite,
+        reasoning: Schema.Finite,
+        cache: Schema.Struct({
+            read: Schema.Finite,
+            write: Schema.Finite,
+        }),
+    }),
+    structured: Schema.optional(Schema.Any),
+    variant: Schema.optional(Schema.String),
+    finish: Schema.optional(Schema.String),
+}).annotate({ identifier: "SessionV1.AssistantMessage" });
+export const Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "SessionV1.Message" });
+export const WithParts = Schema.Struct({
+    info: Info,
+    parts: Schema.Array(Part),
+});
+const options = {
+    durable: {
+        aggregate: "sessionID",
+        version: 1,
+    },
+};
+const SessionSummary = Schema.Struct({
+    additions: Schema.Finite,
+    deletions: Schema.Finite,
+    files: Schema.Finite,
+    diffs: optional(Schema.Array(FileDiff.LegacyInfo)),
+});
+const SessionTokens = Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    reasoning: Schema.Finite,
+    cache: Schema.Struct({
+        read: Schema.Finite,
+        write: Schema.Finite,
+    }),
+});
+const SessionShare = Schema.Struct({
+    url: Schema.String,
+});
+const SessionRevert = Schema.Struct({
+    messageID: MessageID,
+    partID: optional(PartID),
+    snapshot: optional(Schema.String),
+    diff: optional(Schema.String),
+});
+const SessionModel = Schema.Struct({
+    id: Model.ID,
+    providerID: Provider.ID,
+    variant: optional(Schema.String),
+});
+export const SessionInfo = Schema.Struct({
+    id: SessionID,
+    slug: Schema.String,
+    projectID: Project.ID,
+    workspaceID: optional(WorkspaceID),
+    directory: Schema.String,
+    path: optional(Schema.String),
+    parentID: optional(SessionID),
+    summary: optional(SessionSummary),
+    cost: optional(Schema.Finite),
+    tokens: optional(SessionTokens),
+    share: optional(SessionShare),
+    title: optional(Schema.String),
+    agent: optional(Schema.String),
+    model: optional(SessionModel),
+    version: Schema.String,
+    metadata: optional(Schema.Record(Schema.String, Schema.Any)),
+    time: Schema.Struct({
+        created: NonNegativeInt,
+        updated: NonNegativeInt,
+        compacting: optional(NonNegativeInt),
+        archived: optional(Schema.Finite),
+    }),
+    permission: optional(PermissionV1.Ruleset),
+    revert: optional(SessionRevert),
+}).annotate({ identifier: "SessionV1.Info" });
+const events = {
+    Created: durable({
+        type: "session.created",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            info: SessionInfo,
+        },
+    }),
+    Updated: durable({
+        type: "session.updated",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            info: SessionInfo,
+        },
+    }),
+    Deleted: durable({
+        type: "session.deleted",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            info: SessionInfo,
+        },
+    }),
+    MessageUpdated: durable({
+        type: "message.updated",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            info: Info,
+        },
+    }),
+    MessageRemoved: durable({
+        type: "message.removed",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            messageID: MessageID,
+        },
+    }),
+    PartUpdated: durable({
+        type: "message.part.updated",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            part: Part,
+            time: Schema.Finite,
+        },
+    }),
+    PartRemoved: durable({
+        type: "message.part.removed",
+        ...options,
+        schema: {
+            sessionID: SessionID,
+            messageID: MessageID,
+            partID: PartID,
+        },
+    }),
+};
+export const PartDelta = ephemeral({
+    type: "message.part.delta",
+    schema: {
+        sessionID: SessionID,
+        messageID: MessageID,
+        partID: PartID,
+        field: Schema.String,
+        delta: Schema.String,
+    },
+});
+export const Diff = ephemeral({
+    type: "session.diff",
+    schema: {
+        sessionID: SessionID,
+        diff: Schema.Array(FileDiff.LegacyInfo),
+    },
+});
+export const Error = ephemeral({
+    type: "session.error",
+    schema: {
+        sessionID: Schema.optional(SessionID),
+        error: Assistant.fields.error,
+    },
+});
+export const Event = {
+    ...events,
+    PartDelta,
+    Diff,
+    Error,
+    Definitions: inventory(events.Created, events.Updated, events.Deleted, events.MessageUpdated, events.MessageRemoved, events.PartUpdated, events.PartRemoved, PartDelta, Diff, Error),
+};

package/dist/vcs-event.d.ts

@@ -0,0 +1,76 @@
+export * as VcsEvent from "./vcs-event.js";
+import { Schema } from "effect";
+export declare const BranchUpdated: 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<"vcs.branch.updated">;
+    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 branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}> & {
+    type: "vcs.branch.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+};
+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<"vcs.branch.updated">;
+    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 branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}> & {
+    type: "vcs.branch.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}];

package/dist/vcs-event.js

@@ -0,0 +1,11 @@
+export * as VcsEvent from "./vcs-event.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Event } from "./event.js";
+export const BranchUpdated = Event.ephemeral({
+    type: "vcs.branch.updated",
+    schema: {
+        branch: optional(Schema.String),
+    },
+});
+export const Definitions = Event.inventory(BranchUpdated);

package/dist/vcs.d.ts

@@ -0,0 +1,26 @@
+export * as Vcs from "./vcs.js";
+import { Schema } from "effect";
+export declare const Branch: Schema.Struct<{
+    readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface Branch extends Schema.Schema.Type<typeof Branch> {
+}
+export declare const Info: Schema.Struct<{
+    readonly branch: Schema.Struct<{
+        readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Mode: Schema.Literals<readonly ["working", "branch"]>;
+export type Mode = typeof Mode.Type;
+export declare const FileStatus: Schema.Struct<{
+    readonly file: Schema.String;
+    readonly additions: Schema.Int;
+    readonly deletions: Schema.Int;
+    readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+}>;
+export interface FileStatus extends Schema.Schema.Type<typeof FileStatus> {
+}

package/dist/vcs.js

@@ -0,0 +1,17 @@
+export * as Vcs from "./vcs.js";
+import { Schema } from "effect";
+import { NonNegativeInt, optional } from "./schema.js";
+export const Branch = Schema.Struct({
+    current: optional(Schema.String),
+    default: optional(Schema.String),
+}).annotate({ identifier: "Vcs.Branch" });
+export const Info = Schema.Struct({
+    branch: Branch,
+}).annotate({ identifier: "Vcs.Info" });
+export const Mode = Schema.Literals(["working", "branch"]).annotate({ identifier: "Vcs.Mode" });
+export const FileStatus = Schema.Struct({
+    file: Schema.String,
+    additions: NonNegativeInt,
+    deletions: NonNegativeInt,
+    status: Schema.Literals(["added", "deleted", "modified"]),
+}).annotate({ identifier: "Vcs.FileStatus" });