@opencode-ai/schema 0.0.0-dev-17471

package/dist/config.d.ts

@@ -0,0 +1,175 @@
+export * as Config from "./config.js";
+import { Schema } from "effect";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly $schema: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly shell: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }>]>, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }>]>, never, never>>, never, never>;
+    readonly default_agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly autoupdate: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.Literal<"notify">]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.Literal<"notify">]>>, never, never>;
+    readonly share: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["manual", "auto", "disabled"]>>>, Schema.optionalKey<Schema.Literals<readonly ["manual", "auto", "disabled"]>>, never, never>;
+    readonly enterprise: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly username: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>, never, never>;
+    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>, never, never>;
+    readonly snapshots: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly watcher: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigWatcher.Info>>, Schema.optionalKey<typeof ConfigWatcher.Info>, never, never>;
+    readonly formatter: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>, never, never>;
+    readonly lsp: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>, never, never>;
+    readonly media: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMedia.Info>>, Schema.optionalKey<typeof ConfigMedia.Info>, never, never>;
+    readonly tool_output: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigToolOutput.Info>>, Schema.optionalKey<typeof ConfigToolOutput.Info>, never, never>;
+    readonly mcp: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMCP.Info>>, Schema.optionalKey<typeof ConfigMCP.Info>, never, never>;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigCompaction.Info>>, Schema.optionalKey<typeof ConfigCompaction.Info>, never, never>;
+    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>, never, never>;
+    readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly references: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>, never, never>;
+    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>, never, never>;
+    readonly plugins: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>, never, never>;
+    readonly warming: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>, never, never>;
+    readonly providers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>, never, never>;
+    readonly experimental: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigExperimental.Info>>, Schema.optionalKey<typeof ConfigExperimental.Info>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+declare const Document_base: Schema.Class<Document, Schema.Struct<{
+    readonly type: Schema.Literal<"document">;
+    readonly path: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly info: typeof Info;
+}>, {}>;
+export declare class Document extends Document_base {
+}
+declare const Directory_base: Schema.Class<Directory, Schema.Struct<{
+    readonly type: Schema.Literal<"directory">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class Directory extends Directory_base {
+}
+declare const AgentsDirectory_base: Schema.Class<AgentsDirectory, Schema.Struct<{
+    readonly type: Schema.Literal<"agents">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class AgentsDirectory extends AgentsDirectory_base {
+}
+declare const ClaudeDirectory_base: Schema.Class<ClaudeDirectory, Schema.Struct<{
+    readonly type: Schema.Literal<"claude">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class ClaudeDirectory extends ClaudeDirectory_base {
+}
+export declare const Entry: Schema.Union<readonly [typeof Document, typeof Directory, typeof AgentsDirectory, typeof ClaudeDirectory]>;
+export type Entry = typeof Entry.Type;
+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<"config.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: "config.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<"config.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: "config.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};

package/dist/config.js

@@ -0,0 +1,136 @@
+export * as Config from "./config.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { Permission } from "./permission.js";
+import { AbsolutePath, optional } from "./schema.js";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigModel } from "./config/model.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+export class Info extends Schema.Class("Config.Info")({
+    $schema: optional(Schema.String).annotate({
+        description: "JSON schema reference for configuration validation",
+    }),
+    shell: Schema.String.pipe(optional).annotate({
+        description: "Default shell to use for terminal and shell tool execution",
+    }),
+    model: ConfigModel.Selection.pipe(optional).annotate({
+        description: "Default model to use when no session or agent model is selected",
+    }),
+    default_agent: Schema.String.pipe(optional).annotate({
+        description: "Default primary agent to use when no session agent is selected",
+    }),
+    autoupdate: Schema.Union([Schema.Boolean, Schema.Literal("notify")])
+        .pipe(optional)
+        .annotate({
+        description: "Automatically update or notify when a new version is available",
+    }),
+    share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
+        description: "Control whether sessions may be shared manually, automatically, or not at all",
+    }),
+    enterprise: Schema.Struct({
+        url: Schema.String.pipe(optional),
+    })
+        .pipe(optional)
+        .annotate({
+        description: "Enterprise sharing service configuration",
+    }),
+    username: Schema.String.pipe(optional).annotate({
+        description: "Username displayed in conversations and used for telemetry identity",
+    }),
+    permissions: Permission.Ruleset.pipe(optional).annotate({
+        description: "Ordered tool permission rules applied to agent tool use",
+    }),
+    agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(optional).annotate({
+        description: "Named built-in agent overrides and custom agent definitions",
+    }),
+    snapshots: Schema.Boolean.pipe(optional).annotate({
+        description: "Enable snapshots used for undo and revert behavior",
+    }),
+    watcher: ConfigWatcher.Info.pipe(optional).annotate({
+        description: "Filesystem watcher configuration",
+    }),
+    formatter: ConfigFormatter.Info.pipe(optional).annotate({
+        description: "Enable built-in formatters or configure formatter overrides",
+    }),
+    lsp: ConfigLSP.Info.pipe(optional).annotate({
+        description: "Enable built-in language servers or configure server overrides",
+    }),
+    media: ConfigMedia.Info.pipe(optional).annotate({
+        description: "Media processing configuration",
+    }),
+    tool_output: ConfigToolOutput.Info.pipe(optional).annotate({
+        description: "Tool output truncation thresholds",
+    }),
+    mcp: ConfigMCP.Info.pipe(optional).annotate({
+        description: "MCP server configuration",
+    }),
+    compaction: ConfigCompaction.Info.pipe(optional).annotate({
+        description: "Conversation compaction behavior",
+    }),
+    skills: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs to discover skills from",
+    }),
+    commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(optional).annotate({
+        description: "Named slash command definitions",
+    }),
+    instructions: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs supplying ambient instructions",
+    }),
+    references: ConfigReference.Info.pipe(optional).annotate({
+        description: "Named local directories or Git repositories available as external context",
+    }),
+    websearch: ConfigWebSearch.Selection.pipe(optional).annotate({
+        description: "Web search provider selection",
+    }),
+    plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
+        description: "Ordered plugin enablement directives and external package declarations",
+    }),
+    warming: ConfigWarming.Warming.pipe(optional).annotate({
+        description: "Keep recently active sessions warm with transient model requests (default: false)",
+    }),
+    providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(optional),
+    experimental: ConfigExperimental.Info.pipe(optional),
+}) {
+}
+export class Document extends Schema.Class("Config.Document")({
+    type: Schema.Literal("document"),
+    path: AbsolutePath.pipe(optional),
+    info: Info,
+}) {
+}
+export class Directory extends Schema.Class("Config.Directory")({
+    type: Schema.Literal("directory"),
+    path: AbsolutePath,
+}) {
+}
+export class AgentsDirectory extends Schema.Class("Config.AgentsDirectory")({
+    type: Schema.Literal("agents"),
+    path: AbsolutePath,
+}) {
+}
+export class ClaudeDirectory extends Schema.Class("Config.ClaudeDirectory")({
+    type: Schema.Literal("claude"),
+    path: AbsolutePath,
+}) {
+}
+export const Entry = Schema.Union([Document, Directory, AgentsDirectory, ClaudeDirectory]).annotate({
+    identifier: "Config.Entry",
+});
+const Updated = ephemeral({
+    type: "config.updated",
+    schema: {},
+});
+export const Event = { Updated, Definitions: inventory(Updated) };

package/dist/connection.d.ts

@@ -0,0 +1,28 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+export interface CredentialInfo extends Schema.Schema.Type<typeof CredentialInfo> {
+}
+export declare const CredentialInfo: Schema.Struct<{
+    readonly type: Schema.Literal<"credential">;
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly label: Schema.String;
+}>;
+export interface EnvInfo extends Schema.Schema.Type<typeof EnvInfo> {
+}
+export declare const EnvInfo: Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+}>;
+export declare const Info: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"credential">;
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly label: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+}>]>;
+export type Info = typeof Info.Type;

package/dist/connection.js

@@ -0,0 +1,15 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+import { Credential } from "./credential.js";
+export const CredentialInfo = Schema.Struct({
+    type: Schema.Literal("credential"),
+    id: Credential.ID,
+    label: Schema.String,
+}).annotate({ identifier: "Connection.CredentialInfo" });
+export const EnvInfo = Schema.Struct({
+    type: Schema.Literal("env"),
+    name: Schema.String,
+}).annotate({ identifier: "Connection.EnvInfo" });
+export const Info = Schema.Union([CredentialInfo, EnvInfo])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Connection.Info" });

package/dist/credential.d.ts

@@ -0,0 +1,38 @@
+export * as Credential from "./credential.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Credential.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+};
+export type ID = typeof ID.Type;
+export interface OAuth extends Schema.Schema.Type<typeof OAuth> {
+}
+export declare const OAuth: Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export interface Key extends Schema.Schema.Type<typeof Key> {
+}
+export declare const Key: Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    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 configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>;
+export declare const Value: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    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 configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>]>;
+export type Value = Schema.Schema.Type<typeof Value>;

package/dist/credential.js

@@ -0,0 +1,25 @@
+export * as Credential from "./credential.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { IntegrationMethodID } from "./integration-id.js";
+import { ascending } from "./identifier.js";
+import { NonNegativeInt, statics } from "./schema.js";
+import { Form } from "./form.js";
+export const ID = Schema.String.pipe(Schema.brand("Credential.ID"), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
+export const OAuth = Schema.Struct({
+    type: Schema.Literal("oauth"),
+    methodID: IntegrationMethodID,
+    refresh: Schema.String,
+    access: Schema.String,
+    expires: NonNegativeInt,
+    metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "Credential.OAuth" });
+export const Key = Schema.Struct({
+    type: Schema.Literal("key"),
+    key: Schema.String,
+    metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+    configuration: optional(Form.Answer),
+}).annotate({ identifier: "Credential.Key" });
+export const Value = Schema.Union([OAuth, Key])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Credential.Value" });

package/dist/durable-event-manifest.d.ts

@@ -0,0 +1,3 @@
+export * as DurableEventManifest from "./durable-event-manifest.js";
+import { Event } from "./event.js";
+export declare const Durable: ReadonlyMap<string, Event.DurableDefinition<string, import("effect/Schema").Codec<unknown, unknown, never, never>>>;

package/dist/durable-event-manifest.js

@@ -0,0 +1,5 @@
+export * as DurableEventManifest from "./durable-event-manifest.js";
+import { Event } from "./event.js";
+import { Worktree } from "./worktree.js";
+import { SessionEvent } from "./session-event.js";
+export const Durable = Event.durableMap([...SessionEvent.DurableDefinitions, Worktree.Event.Resolved]);

package/dist/event-log.d.ts

@@ -0,0 +1,14 @@
+export * as EventLog from "./event-log.js";
+import { Schema } from "effect";
+/**
+ * Replay-to-live boundary marker for a durable log read. The reader now holds
+ * every event committed at or below this watermark; `seq` is absent when the
+ * captured watermark is empty. Emitted once for the captured watermark.
+ */
+export declare const Synced: Schema.Struct<{
+    readonly type: Schema.Literal<"log.synced">;
+    readonly aggregateID: Schema.String;
+    readonly seq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Int, "Event.Seq">>>, Schema.optionalKey<Schema.brand<Schema.Int, "Event.Seq">>, never, never>;
+}>;
+export interface Synced extends Schema.Schema.Type<typeof Synced> {
+}

package/dist/event-log.js

@@ -0,0 +1,17 @@
+export * as EventLog from "./event-log.js";
+import { Schema } from "effect";
+import { Event } from "./event.js";
+import { optional } from "./schema.js";
+/**
+ * Replay-to-live boundary marker for a durable log read. The reader now holds
+ * every event committed at or below this watermark; `seq` is absent when the
+ * captured watermark is empty. Emitted once for the captured watermark.
+ */
+export const Synced = Schema.Struct({
+    type: Schema.Literal("log.synced"),
+    aggregateID: Schema.String,
+    seq: optional(Event.Seq),
+}).annotate({
+    identifier: "EventLog.Synced",
+    description: "Marker emitted once when a log read reaches its captured watermark. The reader holds every event committed at or below seq.",
+});