@opencode-ai/schema 0.0.0-next-14723 → 0.0.0-next-14730

package/dist/form.js

@@ -0,0 +1,105 @@
+export * as Form from "./form.js";
+import { Schema } from "effect";
+import { define, inventory } from "./event.js";
+import { ascending } from "./identifier.js";
+import { NonNegativeInt, optional, statics } from "./schema.js";
+const IDSchema = Schema.String.check(Schema.isStartsWith("frm_")).pipe(Schema.brand("Form.ID"));
+export const ID = IDSchema.pipe(statics((schema) => ({ create: (id) => schema.make(id ?? "frm_" + ascending()) })));
+export const Metadata = Schema.Record(Schema.String, Schema.Unknown).annotate({ identifier: "Form.Metadata" });
+export const Option = Schema.Struct({
+    value: Schema.String,
+    label: Schema.String,
+    description: Schema.String.pipe(optional),
+}).annotate({ identifier: "Form.Option" });
+export const When = Schema.Struct({
+    key: Schema.String,
+    op: Schema.Literals(["eq", "neq"]),
+    value: Schema.String,
+}).annotate({ identifier: "Form.When" });
+const FieldBase = {
+    key: Schema.String,
+    title: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    required: Schema.Boolean.pipe(optional),
+    when: When.pipe(optional),
+};
+export const StringField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("string"),
+    format: Schema.Literals(["email", "uri", "date", "date-time"]).pipe(optional),
+    minLength: NonNegativeInt.pipe(optional),
+    maxLength: NonNegativeInt.pipe(optional),
+    pattern: Schema.String.pipe(optional),
+    placeholder: Schema.String.pipe(optional),
+    default: Schema.String.pipe(optional),
+    options: Schema.Array(Option).pipe(optional),
+    custom: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Form.StringField" });
+export const NumberField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("number"),
+    minimum: Schema.Number.pipe(optional),
+    maximum: Schema.Number.pipe(optional),
+    default: Schema.Number.pipe(optional),
+}).annotate({ identifier: "Form.NumberField" });
+export const IntegerField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("integer"),
+    minimum: Schema.Number.pipe(optional),
+    maximum: Schema.Number.pipe(optional),
+    default: Schema.Number.pipe(optional),
+}).annotate({ identifier: "Form.IntegerField" });
+export const BooleanField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("boolean"),
+    default: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Form.BooleanField" });
+export const MultiselectField = Schema.Struct({
+    ...FieldBase,
+    type: Schema.Literal("multiselect"),
+    options: Schema.Array(Option),
+    minItems: NonNegativeInt.pipe(optional),
+    maxItems: NonNegativeInt.pipe(optional),
+    custom: Schema.Boolean.pipe(optional),
+    default: Schema.Array(Schema.String).pipe(optional),
+}).annotate({ identifier: "Form.MultiselectField" });
+export const Field = Schema.Union([StringField, NumberField, IntegerField, BooleanField, MultiselectField]).pipe(Schema.toTaggedUnion("type"));
+const InfoBase = {
+    id: ID,
+    // Public form flows are session-owned. This is intentionally `string` because the server
+    // currently accepts an undocumented `global` sentinel for MCP elicitation forms that cannot
+    // be attributed to a concrete session yet. Do not document or rely on `global` outside our
+    // own clients; remove the sentinel path once MCP elicitation can carry session ownership.
+    sessionID: Schema.String,
+    title: Schema.String.pipe(optional),
+    metadata: Metadata.pipe(optional),
+};
+export const FormInfo = Schema.Struct({
+    ...InfoBase,
+    mode: Schema.Literal("form"),
+    fields: Schema.Array(Field),
+}).annotate({ identifier: "Form.FormInfo" });
+export const UrlInfo = Schema.Struct({
+    ...InfoBase,
+    mode: Schema.Literal("url"),
+    url: Schema.String,
+}).annotate({ identifier: "Form.UrlInfo" });
+export const Info = Schema.Union([FormInfo, UrlInfo]).pipe(Schema.toTaggedUnion("mode"));
+export const Value = Schema.Union([Schema.String, Schema.Number, Schema.Boolean, Schema.Array(Schema.String)]).annotate({
+    identifier: "Form.Value",
+});
+export const Answer = Schema.Record(Schema.String, Value).annotate({ identifier: "Form.Answer" });
+export const State = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("pending") }),
+    Schema.Struct({ status: Schema.Literal("answered"), answer: Answer }),
+    Schema.Struct({ status: Schema.Literal("cancelled") }),
+])
+    .pipe(Schema.toTaggedUnion("status"))
+    .annotate({ identifier: "Form.State" });
+export const Reply = Schema.Struct({
+    answer: Answer,
+}).annotate({ identifier: "Form.Reply" });
+const Created = define({ type: "form.created", schema: { form: Info } });
+const Replied = define({ type: "form.replied", schema: { id: ID, sessionID: Schema.String, answer: Answer } });
+const Cancelled = define({ type: "form.cancelled", schema: { id: ID, sessionID: Schema.String } });
+export const Event = { Created, Replied, Cancelled, Definitions: inventory(Created, Replied, Cancelled) };

package/dist/ide-event.d.ts

@@ -8,12 +8,12 @@ export declare const Installed: Schema.Struct<{
     readonly type: Schema.Literal<"ide.installed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -55,12 +55,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"ide.installed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { Connection } from "./connection.js";
 export { Credential } from "./credential.js";
 export { Event } from "./event.js";
 export { FileSystem } from "./filesystem.js";
+export { Form } from "./form.js";
 export { Integration } from "./integration.js";
 export { LLM } from "./llm.js";
 export { Location } from "./location.js";
@@ -22,7 +23,6 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { Pty } from "./pty.js";
 export { PtyTicket } from "./pty-ticket.js";
-export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";
 export { Prompt, Source, FileAttachment, AgentAttachment } from "./prompt.js";
 export { PromptInput } from "./prompt-input.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export { Connection } from "./connection.js";
 export { Credential } from "./credential.js";
 export { Event } from "./event.js";
 export { FileSystem } from "./filesystem.js";
+export { Form } from "./form.js";
 export { Integration } from "./integration.js";
 export { LLM } from "./llm.js";
 export { Location } from "./location.js";
@@ -22,7 +23,6 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { Pty } from "./pty.js";
 export { PtyTicket } from "./pty-ticket.js";
-export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";
 export { Prompt, Source, FileAttachment, AgentAttachment } from "./prompt.js";
 export { PromptInput } from "./prompt-input.js";

package/dist/installation-event.d.ts

@@ -8,12 +8,12 @@ export declare const Updated: Schema.Struct<{
     readonly type: Schema.Literal<"installation.updated">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -55,12 +55,12 @@ export declare const UpdateAvailable: Schema.Struct<{
     readonly type: Schema.Literal<"installation.update-available">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -102,12 +102,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"installation.updated">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -148,12 +148,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"installation.update-available">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/integration.d.ts

@@ -255,12 +255,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"integration.updated">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -298,12 +298,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"integration.connection.updated">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -345,12 +345,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"integration.updated">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -387,12 +387,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"integration.connection.updated">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/lsp-event.d.ts

@@ -7,12 +7,12 @@ export declare const Updated: import("effect/Schema").Struct<{
     readonly type: import("effect/Schema").Literal<"lsp.updated">;
     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;
+        readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+        readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
     }>>>, 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;
+        readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+        readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
     }>>, 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">;
@@ -50,12 +50,12 @@ export declare const Definitions: readonly [import("effect/Schema").Struct<{
     readonly type: import("effect/Schema").Literal<"lsp.updated">;
     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;
+        readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+        readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
     }>>>, 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;
+        readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+        readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
     }>>, 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">;

package/dist/mcp-event.d.ts

@@ -8,12 +8,12 @@ export declare const ToolsChanged: Schema.Struct<{
     readonly type: Schema.Literal<"mcp.tools.changed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -55,12 +55,12 @@ export declare const BrowserOpenFailed: Schema.Struct<{
     readonly type: Schema.Literal<"mcp.browser.open.failed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -104,12 +104,12 @@ export declare const StatusChanged: Schema.Struct<{
     readonly type: Schema.Literal<"mcp.status.changed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -151,12 +151,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"mcp.tools.changed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -197,12 +197,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"mcp.browser.open.failed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -245,12 +245,12 @@ export declare const Definitions: readonly [Schema.Struct<{
     readonly type: Schema.Literal<"mcp.status.changed">;
     readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly aggregateID: Schema.String;
-        readonly seq: Schema.Int;
-        readonly version: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.brand<Schema.Int, "Event.Version">;
     }>>, never, never>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/models-dev.d.ts

@@ -8,12 +8,12 @@ export declare const Event: {
         readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
         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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>>, 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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>, 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">;
@@ -51,12 +51,12 @@ export declare const Event: {
         readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
         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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>>, 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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>, 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">;

package/dist/permission.d.ts

@@ -45,12 +45,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"permission.v2.asked">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -130,12 +130,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"permission.v2.replied">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -191,12 +191,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"permission.v2.asked">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -275,12 +275,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"permission.v2.replied">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/plugin.d.ts

@@ -16,12 +16,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"plugin.added">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -63,12 +63,12 @@ export declare const Event: {
         readonly type: Schema.Literal<"plugin.added">;
         readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly aggregateID: Schema.String;
-            readonly seq: Schema.Int;
-            readonly version: Schema.Int;
+            readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+            readonly version: Schema.brand<Schema.Int, "Event.Version">;
         }>>, never, never>;
         readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/project-directories.d.ts

@@ -8,12 +8,12 @@ export declare const Event: {
         readonly type: import("effect/Schema").Literal<"project.directories.updated">;
         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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>>, 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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>, 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">;
@@ -59,12 +59,12 @@ export declare const Event: {
         readonly type: import("effect/Schema").Literal<"project.directories.updated">;
         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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>>, 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;
+            readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
+            readonly version: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Version">;
         }>>, 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">;