@opencode/schema 0.0.0-reserved → 2.0.1

package/dist/reference.d.ts

@@ -0,0 +1,120 @@
+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 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<"reference.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<{}>;
+    }> & {
+        type: "reference.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    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<"reference.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<{}>;
+    }> & {
+        type: "reference.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};
+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;
+export declare const 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 interface Info extends Schema.Schema.Type<typeof Info> {
+}

package/dist/reference.js

@@ -0,0 +1,30 @@
+export * as Reference from "./reference.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { ephemeral, inventory } from "./event.js";
+import { AbsolutePath } from "./schema.js";
+const Updated = ephemeral({ 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 const Info = Schema.Struct({
+    name: Schema.String,
+    path: AbsolutePath,
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+    source: Source,
+}).annotate({ identifier: "Reference.Info" });

package/dist/rpc.d.ts

@@ -0,0 +1,111 @@
+export * as Rpc from "./rpc.js";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { JsonSchema, Schema } from "effect";
+import type { Event } from "./event.js";
+import type { Location } from "./location.js";
+import type { Tool } from "./tool.js";
+export type ErrorMap = Readonly<Record<string, Tool.ValueSchema>> & {
+    readonly [Name in `rpc.${string}`]?: never;
+};
+export interface Method {
+    readonly input: Tool.ValueSchema;
+    readonly output: Tool.ValueSchema;
+    readonly errors?: ErrorMap;
+}
+export type PortableValueSchema = StandardSchemaV1<unknown, unknown> | JsonSchema.JsonSchema;
+export interface PortableMethod extends Method {
+    readonly input: PortableValueSchema;
+    readonly output: PortableValueSchema;
+    readonly errors?: Readonly<Record<string, PortableValueSchema>> & {
+        readonly [Name in `rpc.${string}`]?: never;
+    };
+}
+type EventDataObject = Readonly<Record<string, unknown>>;
+type EventValueSchema = Schema.Codec<EventDataObject, EventDataObject> | StandardSchemaV1<unknown, EventDataObject> | (JsonSchema.JsonSchema & {
+    readonly type: "object";
+});
+type PortableEventValueSchema = StandardSchemaV1<unknown, EventDataObject> | (JsonSchema.JsonSchema & {
+    readonly type: "object";
+});
+export interface EventDefinition {
+    readonly schema: EventValueSchema;
+}
+export type PortableEventDefinition = EventDefinition & {
+    readonly schema: PortableEventValueSchema;
+};
+export interface Definition {
+    readonly id: string;
+    readonly methods: Readonly<Record<string, Method>> & {
+        readonly events?: never;
+    };
+    readonly events: Readonly<Record<string, EventDefinition>>;
+}
+export interface PortableDefinition extends Definition {
+    readonly methods: Readonly<Record<string, PortableMethod>> & {
+        readonly events?: never;
+    };
+    readonly events: Readonly<Record<string, PortableEventDefinition>>;
+}
+export declare function define<const D extends Definition>(definition: D): D;
+export type Input<S extends Tool.ValueSchema> = S extends Schema.Top ? S["Encoded"] : S extends StandardSchemaV1 ? StandardSchemaV1.InferInput<S> : unknown;
+export type Output<S extends Tool.ValueSchema> = S extends Schema.Top ? S["Type"] : S extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<S> : unknown;
+export type HandlerOutput<S extends Tool.ValueSchema> = S extends Schema.Top ? Output<S> : Input<S>;
+type MethodErrors<M extends Method> = M extends {
+    readonly errors: infer Errors extends ErrorMap;
+} ? Errors : never;
+type ErrorSchema<M extends Method, Name extends ErrorName<M>> = MethodErrors<M>[Name];
+type ErrorData<Data> = unknown extends Data ? {
+    readonly data: Data;
+} : undefined extends Data ? {
+    readonly data?: Data;
+} : {
+    readonly data: Data;
+};
+type ErrorDataArguments<Data> = unknown extends Data ? [data: Data] : undefined extends Data ? [data?: Data] : [data: Data];
+type Simplify<A> = {
+    readonly [K in keyof A]: A[K];
+};
+declare const HandlerErrorTypeId: unique symbol;
+export interface Failure<Type extends string = string, Data = unknown> {
+    readonly type: Type;
+    readonly message: string;
+    readonly data?: Data;
+}
+export type SystemError = Failure<"rpc.unavailable" | "rpc.method_not_found" | "rpc.invalid_input" | "rpc.invalid_output" | "rpc.internal", never>;
+export type ErrorName<M extends Method> = M extends {
+    readonly errors: infer Errors extends ErrorMap;
+} ? Exclude<keyof Errors & string, `rpc.${string}`> : never;
+export type HandlerErrorFor<M extends Method, Name extends ErrorName<M>> = Simplify<{
+    readonly type: Name;
+    readonly message: string;
+    readonly [HandlerErrorTypeId]: true;
+} & ErrorData<HandlerOutput<ErrorSchema<M, Name>>>>;
+export type HandlerError<M extends Method> = {
+    readonly [Name in ErrorName<M>]: HandlerErrorFor<M, Name>;
+}[ErrorName<M>];
+export type MethodErrorFor<M extends Method, Name extends ErrorName<M>> = Simplify<{
+    readonly type: Name;
+    readonly message: string;
+} & ErrorData<Output<ErrorSchema<M, Name>>>>;
+export type MethodError<M extends Method> = {
+    readonly [Name in ErrorName<M>]: MethodErrorFor<M, Name>;
+}[ErrorName<M>];
+export type ErrorArguments<M extends Method, Name extends ErrorName<M>> = [
+    type: Name,
+    message: string,
+    ...data: ErrorDataArguments<HandlerOutput<ErrorSchema<M, Name>>>
+];
+export type ErrorFactory<M extends Method> = <Name extends ErrorName<M>>(...args: ErrorArguments<M, Name>) => HandlerErrorFor<M, Name>;
+export type EventInputData<S extends EventValueSchema> = S extends JsonSchema.JsonSchema ? EventDataObject : HandlerOutput<S>;
+export type EventData<S extends EventValueSchema> = S extends JsonSchema.JsonSchema ? EventDataObject : Output<S>;
+export type EventInput<D extends Definition> = {
+    [Name in keyof D["events"] & string]: [name: Name, data: EventInputData<D["events"][Name]["schema"]>];
+}[keyof D["events"] & string];
+type EventPayloadFor<D extends Definition, Name extends keyof D["events"] & string> = Omit<Event.Payload<Event.EphemeralDefinition>, "type" | "data" | "durable" | "location"> & {
+    readonly type: `rpc.${D["id"]}.${Name}`;
+    readonly data: EventData<D["events"][Name]["schema"]>;
+    readonly location: Location.Ref;
+};
+export type EventPayload<D extends Definition, Name extends keyof D["events"] & string = keyof D["events"] & string> = {
+    readonly [K in Name]: EventPayloadFor<D, K>;
+}[Name];

package/dist/rpc.js

@@ -0,0 +1,9 @@
+export * as Rpc from "./rpc.js";
+export function define(definition) {
+    const reserved = Object.values(definition.methods)
+        .flatMap((method) => Object.keys(method.errors ?? {}))
+        .find((name) => name.startsWith("rpc."));
+    if (reserved)
+        throw new Error(`RPC error names starting with "rpc." are reserved: ${reserved}`);
+    return definition;
+}

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,132 @@
+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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "server.connected";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+};
+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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "global.disposed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+};
+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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "server.connected";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}, 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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "global.disposed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}];

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.ephemeral({ type: "server.connected", schema: {} });
+export const Disposed = Event.ephemeral({ type: "global.disposed", schema: {} });
+export const Definitions = Event.inventory(Connected, Disposed);

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

@@ -0,0 +1,87 @@
+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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: 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">;
+        };
+    }>;
+}> & {
+    type: "session.compacted";
+    durability: "ephemeral";
+    durable: undefined;
+    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">;
+        };
+    }>;
+};
+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 created: import("effect/Schema").Finite;
+    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 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: 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">;
+        };
+    }>;
+}> & {
+    type: "session.compacted";
+    durability: "ephemeral";
+    durable: undefined;
+    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">;
+        };
+    }>;
+}];

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.ephemeral({
+    type: "session.compacted",
+    schema: {
+        sessionID: SessionID,
+    },
+});
+export const Definitions = Event.inventory(Compacted);

package/dist/session-error.d.ts

@@ -0,0 +1,9 @@
+export * as SessionError from "./session-error.js";
+import { Schema } from "effect";
+export interface Error extends Schema.Schema.Type<typeof Error> {
+}
+export declare const Error: Schema.Struct<{
+    readonly type: Schema.String;
+    readonly message: Schema.String;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;

package/dist/session-error.js

@@ -0,0 +1,8 @@
+export * as SessionError from "./session-error.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+export const Error = Schema.Struct({
+    type: Schema.String,
+    message: Schema.String,
+    status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })).pipe(optional),
+}).annotate({ identifier: "Session.StructuredError" });