@opencode-ai/schema 0.0.0-next-14659

package/dist/reference.d.ts

@@ -0,0 +1,140 @@
+export * as Reference from "./reference.js";
+import { Schema } from "effect";
+export declare const Event: {
+    Updated: 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<"reference.updated">;
+        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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "reference.updated";
+    };
+    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<"reference.updated">;
+        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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "reference.updated";
+    }];
+};
+export interface LocalSource extends Schema.Schema.Type<typeof LocalSource> {
+}
+export declare const LocalSource: Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface GitSource extends Schema.Schema.Type<typeof GitSource> {
+}
+export declare const GitSource: Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly repository: Schema.String;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export declare const Source: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly repository: Schema.String;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>]>;
+export type Source = typeof Source.Type;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly name: Schema.String;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"local">;
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly repository: Schema.String;
+        readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>]>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/reference.js

@@ -0,0 +1,31 @@
+export * as Reference from "./reference.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { define, inventory } from "./event.js";
+import { AbsolutePath } from "./schema.js";
+const Updated = define({ type: "reference.updated", schema: {} });
+export const Event = { Updated, Definitions: inventory(Updated) };
+export const LocalSource = Schema.Struct({
+    type: Schema.Literal("local"),
+    path: AbsolutePath,
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Reference.LocalSource" });
+export const GitSource = Schema.Struct({
+    type: Schema.Literal("git"),
+    repository: Schema.String,
+    branch: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Reference.GitSource" });
+export const Source = Schema.Union([LocalSource, GitSource])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Reference.Source" });
+export class Info extends Schema.Class("Reference.Info")({
+    name: Schema.String,
+    path: AbsolutePath,
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+    source: Source,
+}) {
+}

package/dist/revert.d.ts

@@ -0,0 +1,34 @@
+export * as Revert from "./revert.js";
+import { Schema } from "effect";
+export declare const FileDiff: Schema.Struct<{
+    readonly path: Schema.brand<Schema.String, "RelativePath">;
+    readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+    readonly additions: Schema.Int;
+    readonly deletions: Schema.Int;
+    readonly patch: Schema.String;
+}>;
+export interface FileDiff extends Schema.Schema.Type<typeof FileDiff> {
+}
+export declare const State: Schema.Struct<{
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+    readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly diff: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly patch: Schema.String;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly patch: Schema.String;
+    }>>>, never, never>;
+}>;
+export interface State extends Schema.Schema.Type<typeof State> {
+}

package/dist/revert.js

@@ -0,0 +1,19 @@
+export * as Revert from "./revert.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { NonNegativeInt, RelativePath } from "./schema.js";
+import { SessionMessage } from "./session-message.js";
+export const FileDiff = Schema.Struct({
+    path: RelativePath,
+    status: Schema.Literals(["added", "modified", "deleted"]),
+    additions: NonNegativeInt,
+    deletions: NonNegativeInt,
+    patch: Schema.String,
+}).annotate({ identifier: "File.Diff" });
+export const State = Schema.Struct({
+    messageID: SessionMessage.ID,
+    partID: Schema.String.pipe(optional),
+    snapshot: Schema.String.pipe(optional),
+    diff: Schema.String.pipe(optional),
+    files: Schema.Array(FileDiff).pipe(optional),
+}).annotate({ identifier: "Revert.State" });

package/dist/schema.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+export declare const PositiveInt: Schema.Int;
+export declare const NonNegativeInt: Schema.Int;
+export declare const RelativePath: Schema.brand<Schema.String, "RelativePath">;
+export type RelativePath = typeof RelativePath.Type;
+export declare const AbsolutePath: Schema.brand<Schema.String, "AbsolutePath">;
+export type AbsolutePath = typeof AbsolutePath.Type;
+export declare const optional: <S extends Schema.Top>(schema: S) => Schema.decodeTo<Schema.optional<Schema.toType<S>>, Schema.optionalKey<S>, never, never>;
+export declare const statics: <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) => (schema: S) => S & M;
+export declare const DateTimeUtcFromMillis: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;

package/dist/schema.js

@@ -0,0 +1,14 @@
+import { DateTime, Option, Schema, SchemaGetter } from "effect";
+export const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+export const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"));
+export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"));
+export const optional = (schema) => Schema.optionalKey(schema).pipe(Schema.decodeTo(Schema.optional(Schema.toType(schema)), {
+    decode: SchemaGetter.passthrough({ strict: false }),
+    encode: SchemaGetter.transformOptional(Option.filter((value) => value !== undefined)),
+}));
+export const statics = (methods) => (schema) => Object.assign(schema, methods(schema));
+export const DateTimeUtcFromMillis = Schema.Finite.pipe(Schema.decodeTo(Schema.DateTimeUtc, {
+    decode: SchemaGetter.transform((value) => DateTime.makeUnsafe(value)),
+    encode: SchemaGetter.transform((value) => DateTime.toEpochMillis(value)),
+}));

package/dist/server-event.d.ts

@@ -0,0 +1,172 @@
+export * as ServerEvent from "./server-event.js";
+export declare const Connected: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"server.connected">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "server.connected";
+};
+export declare const Disposed: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"global.disposed">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "global.disposed";
+};
+export declare const Definitions: readonly [import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"server.connected">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "server.connected";
+}, import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"global.disposed">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    data: import("effect/Schema").Struct<{}>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "global.disposed";
+}];

package/dist/server-event.js

@@ -0,0 +1,5 @@
+export * as ServerEvent from "./server-event.js";
+import { Event } from "./event.js";
+export const Connected = Event.define({ type: "server.connected", schema: {} });
+export const Disposed = Event.define({ type: "global.disposed", schema: {} });
+export const Definitions = Event.inventory(Connected, Disposed);

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

@@ -0,0 +1,107 @@
+export * as SessionCompactionEvent from "./session-compaction-event.js";
+export declare const Compacted: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"session.compacted">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.compacted";
+};
+export declare const Definitions: readonly [import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"session.compacted">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
+        }>>, import("effect/Schema").optionalKey<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">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.compacted";
+}];

package/dist/session-compaction-event.js

@@ -0,0 +1,10 @@
+export * as SessionCompactionEvent from "./session-compaction-event.js";
+import { Event } from "./event.js";
+import { SessionID } from "./session-id.js";
+export const Compacted = Event.define({
+    type: "session.compacted",
+    schema: {
+        sessionID: SessionID,
+    },
+});
+export const Definitions = Event.inventory(Compacted);

package/dist/session-delivery.d.ts

@@ -0,0 +1,4 @@
+export * as SessionDelivery from "./session-delivery.js";
+import { Schema } from "effect";
+export declare const Delivery: Schema.Literals<readonly ["steer", "queue"]>;
+export type Delivery = typeof Delivery.Type;

package/dist/session-delivery.js

@@ -0,0 +1,3 @@
+export * as SessionDelivery from "./session-delivery.js";
+import { Schema } from "effect";
+export const Delivery = Schema.Literals(["steer", "queue"]);