@kilocode/schema 0.0.0-stage → 0.0.0-v2-9

package/dist/connection.d.ts

@@ -0,0 +1,79 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+/**
+ * Runtime problem an integration reported for a connection. `needs_auth` asks the user to sign in again:
+ * at `url` when set (the credential itself stays valid), otherwise by reconnecting the integration.
+ */
+export interface Status extends Schema.Schema.Type<typeof Status> {
+}
+export declare const Status: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["needs_auth"]>;
+    readonly message: Schema.String;
+    readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+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;
+    /** Whether the connection stores a key, an OAuth grant, or an external credential-source reference. */
+    readonly method: Schema.Literals<readonly ["key", "oauth", "external"]>;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>;
+export interface EnvInfo extends Schema.Schema.Type<typeof EnvInfo> {
+}
+export declare const EnvInfo: Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>;
+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;
+    /** Whether the connection stores a key, an OAuth grant, or an external credential-source reference. */
+    readonly method: Schema.Literals<readonly ["key", "oauth", "external"]>;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"env">;
+    readonly name: Schema.String;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["needs_auth"]>;
+        readonly message: Schema.String;
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>]>;
+export type Info = typeof Info.Type;

package/dist/connection.js

@@ -0,0 +1,25 @@
+export * as Connection from "./connection.js";
+import { Schema } from "effect";
+import { Credential } from "./credential.js";
+import { optional } from "./schema.js";
+export const Status = Schema.Struct({
+    status: Schema.Literals(["needs_auth"]),
+    message: Schema.String,
+    url: optional(Schema.String),
+}).annotate({ identifier: "Connection.Status" });
+export const CredentialInfo = Schema.Struct({
+    type: Schema.Literal("credential"),
+    id: Credential.ID,
+    label: Schema.String,
+    /** Whether the connection stores a key, an OAuth grant, or an external credential-source reference. */
+    method: Schema.Literals(["key", "oauth", "external"]),
+    status: optional(Status),
+}).annotate({ identifier: "Connection.CredentialInfo" });
+export const EnvInfo = Schema.Struct({
+    type: Schema.Literal("env"),
+    name: Schema.String,
+    status: optional(Status),
+}).annotate({ identifier: "Connection.EnvInfo" });
+export const Info = Schema.Union([CredentialInfo, EnvInfo])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Connection.Info" });

package/dist/credential-legacy.d.ts

@@ -0,0 +1,54 @@
+export * as CredentialLegacy from "./credential-legacy.js";
+import { Schema } from "effect";
+/** Decodes a stored or exported credential value of either shape into the current `Credential.Value`. */
+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.decodeTo<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>;
+}>, 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>;
+}>, never, never>, Schema.Struct<{
+    readonly type: Schema.Literal<"external">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>]>;
+/** Decodes an `auth export` entry of either shape into the current `Credential.Entry`. */
+export declare const Entry: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.String;
+    readonly active: Schema.Boolean;
+    readonly 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.decodeTo<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>;
+    }>, 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>;
+    }>, never, never>, Schema.Struct<{
+        readonly type: Schema.Literal<"external">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>]>;
+}>;

package/dist/credential-legacy.js

@@ -0,0 +1,19 @@
+export * as CredentialLegacy from "./credential-legacy.js";
+import { Schema, SchemaTransformation } from "effect";
+import { Credential } from "./credential.js";
+import { Form } from "./form.js";
+import { optional } from "./schema.js";
+/**
+ * Storage and import compatibility for credentials written before v2.1 (not V1 contracts). Key credentials then kept
+ * their setup-form answers in `configuration`; they now live in `metadata`. Only decoders for stored rows and
+ * `auth export` files use these schemas, so the public credential contract never sees the old field.
+ */
+const Key = Schema.Struct({ ...Credential.Key.fields, configuration: optional(Form.Answer) }).pipe(Schema.decodeTo(Credential.Key, SchemaTransformation.transform({
+    // Form answers overrode metadata when both reached provider settings, so they keep precedence.
+    decode: ({ configuration, ...key }) => configuration === undefined ? key : { ...key, metadata: { ...key.metadata, ...configuration } },
+    encode: (key) => key,
+})));
+/** Decodes a stored or exported credential value of either shape into the current `Credential.Value`. */
+export const Value = Schema.Union([Credential.OAuth, Key, Credential.External]);
+/** Decodes an `auth export` entry of either shape into the current `Credential.Entry`. */
+export const Entry = Schema.Struct({ ...Credential.Entry.fields, value: Value });

package/dist/credential.d.ts

@@ -0,0 +1,255 @@
+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 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<"credential.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: "credential.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    Switched: 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<"credential.switched">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+            readonly credentialID: Schema.NullOr<Schema.brand<Schema.String, "Credential.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+            }>;
+        }>;
+    }> & {
+        type: "credential.switched";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+            readonly credentialID: Schema.NullOr<Schema.brand<Schema.String, "Credential.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+            }>;
+        }>;
+    };
+    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<"credential.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: "credential.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }, 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<"credential.switched">;
+        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+            readonly credentialID: Schema.NullOr<Schema.brand<Schema.String, "Credential.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+            }>;
+        }>;
+    }> & {
+        type: "credential.switched";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+            readonly credentialID: Schema.NullOr<Schema.brand<Schema.String, "Credential.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+            }>;
+        }>;
+    }];
+};
+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>;
+}>;
+/** References a credential source whose secrets and renewal are managed outside the credential store. */
+export interface External extends Schema.Schema.Type<typeof External> {
+}
+export declare const External: Schema.Struct<{
+    readonly type: Schema.Literal<"external">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    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 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>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"external">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    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 type Value = Schema.Schema.Type<typeof Value>;
+export interface Entry extends Schema.Schema.Type<typeof Entry> {
+}
+export declare const Entry: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.String;
+    readonly active: Schema.Boolean;
+    readonly 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>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"external">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        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 CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+export declare const CreateInput: Schema.Struct<{
+    readonly id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    }>, never, never>;
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly 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>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"external">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        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 activate: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;

package/dist/credential.js

@@ -0,0 +1,56 @@
+export * as Credential from "./credential.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { ephemeral, inventory } from "./event.js";
+import { IntegrationID, IntegrationMethodID } from "./integration-id.js";
+import { ascending } from "./identifier.js";
+import { NonNegativeInt, statics } from "./schema.js";
+export const ID = Schema.String.pipe(Schema.brand("Credential.ID"), Schema.annotate({ identifier: "Credential.ID" }), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
+const Updated = ephemeral({
+    type: "credential.updated",
+    schema: {},
+});
+const Switched = ephemeral({
+    type: "credential.switched",
+    schema: { integrationID: IntegrationID, credentialID: Schema.NullOr(ID) },
+});
+export const Event = {
+    Updated,
+    Switched,
+    Definitions: inventory(Updated, Switched),
+};
+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)),
+}).annotate({ identifier: "Credential.Key" });
+export const External = Schema.Struct({
+    type: Schema.Literal("external"),
+    methodID: IntegrationMethodID,
+    metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
+}).annotate({ identifier: "Credential.External" });
+export const Value = Schema.Union([OAuth, Key, External])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Credential.Value" });
+export const Entry = Schema.Struct({
+    id: ID,
+    integrationID: IntegrationID,
+    label: Schema.String,
+    active: Schema.Boolean,
+    value: Value,
+}).annotate({ identifier: "Credential.Entry" });
+export const CreateInput = Schema.Struct({
+    id: optional(ID),
+    integrationID: IntegrationID,
+    label: optional(Schema.String),
+    value: Value,
+    activate: optional(Schema.Boolean),
+}).annotate({ identifier: "Credential.CreateInput" });

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.",
+});