@krak-stack/registry 0.1.11 → 0.1.14

package/dist/services/agent/client/atom.d.ts

@@ -1,4 +1,4 @@
-import { Effect, Stream } from "effect";
+import { Effect, Option, Stream } from "effect";
 import { Atom, Reactivity } from "effect/unstable/reactivity";
 import type { AgentErrorCode, AgentEvent, AgentReference, AgentRequest } from "../schema.js";
 export type AgentToolStatus = "running" | "approval-required" | "approved" | "denied" | "completed" | "failed";
@@ -37,9 +37,9 @@ export type AgentState<Resource = never> = {
 };
 export declare const initialAgentState: AgentState<never>;
 export declare const reduceAgentEvent: <Resource>(state: AgentState<Resource>, event: AgentEvent) => AgentState<Resource>;
-export type AgentAtomsConfig<Resource> = {
-    readonly stream: (get: Atom.FnContext, request: AgentRequest<Resource>) => Effect.Effect<Stream.Stream<AgentEvent, unknown, Reactivity.Reactivity>, unknown>;
-    readonly errorCode?: (error: unknown) => AgentErrorCode;
+export type AgentAtomsConfig<Resource, Failure = ErrorOptions["cause"]> = {
+    readonly stream: (get: Atom.FnContext, request: AgentRequest<Resource>) => Effect.Effect<Stream.Stream<AgentEvent, Failure, Reactivity.Reactivity>, Failure>;
+    readonly errorCode?: (error: Failure) => AgentErrorCode;
     readonly reactivityKeys?: ReadonlyArray<unknown>;
     readonly runtime?: Atom.AtomRuntime<never>;
 };
@@ -48,9 +48,9 @@ export type AgentSubmitInput<Resource> = {
     readonly context?: AgentConversationContext<Resource>;
     readonly scope: string;
 };
-export declare const makeAgentAtoms: <Resource>({ errorCode, reactivityKeys, runtime, stream, }: AgentAtomsConfig<Resource>) => {
-    readonly removeContext: Atom.Writable<import("effect/Option").Option<void>, string>;
-    readonly reset: Atom.Writable<import("effect/Option").Option<void>, string>;
+export declare const makeAgentAtoms: <Resource, Failure = unknown>({ errorCode, reactivityKeys, runtime, stream, }: AgentAtomsConfig<Resource, Failure>) => {
+    readonly removeContext: Atom.Writable<Option.Option<void>, string>;
+    readonly reset: Atom.Writable<Option.Option<void>, string>;
     readonly state: (arg: string) => Atom.Writable<AgentState<Resource>, AgentState<Resource>>;
     readonly submit: Atom.AtomResultFn<AgentSubmitInput<Resource>, void, never>;
 };

package/dist/services/agent/client/index.js

@@ -1,5 +1,5 @@
 // ../../src/services/agent/client/atom.ts
-import { Effect, Layer, Stream } from "effect";
+import { Effect, Layer, Option, Schema, Stream } from "effect";
 import { Atom } from "effect/unstable/reactivity";
 var initialAgentState = {
   context: undefined,
@@ -64,12 +64,15 @@ var reduceAgentEvent = (state, event) => {
       return state;
   }
 };
+var AgentError = Schema.Struct({
+  code: Schema.Literals(["stream-failed", "unavailable"])
+}).annotate({ identifier: "AgentError" });
 var defaultErrorCode = (error) => {
-  if (error && typeof error === "object") {
-    const code = Reflect.get(error, "code");
-    if (code === "stream-failed" || code === "unavailable")
-      return code;
-  }
+  const failure = Schema.decodeUnknownOption(AgentError)(error);
+  if (Option.isNone(failure))
+    return "unavailable";
+  if (failure.value.code === "stream-failed")
+    return "stream-failed";
   return "unavailable";
 };
 var makeAgentAtoms = ({
@@ -628,8 +631,9 @@ function InputGroupAddon({
     "data-align": align,
     className: cn(inputGroupAddonVariants({ align }), className),
     onClick: (event) => {
-      if (event.target.closest("button"))
+      if (event.target instanceof HTMLElement && event.target.closest("button")) {
         return;
+      }
       event.currentTarget.parentElement?.querySelector("input")?.focus();
     },
     ...props
@@ -1346,7 +1350,7 @@ function isCustomStrategy(strategy2) {
 }
 
 // ../../src/services/agent/schema.ts
-import { Schema } from "effect";
+import { Schema as Schema2 } from "effect";
 import {
   HttpApiEndpoint,
   HttpApiError,
@@ -1354,63 +1358,63 @@ import {
   HttpApiSchema,
   OpenApi
 } from "effect/unstable/httpapi";
-var AgentMessageText = Schema.String.check(Schema.isLengthBetween(1, 4000)).annotate({
+var AgentMessageText = Schema2.String.check(Schema2.isLengthBetween(1, 4000)).annotate({
   identifier: "AgentMessageText",
   title: "Agent message",
   description: "A user message sent to the agent."
 });
-var AgentReferenceLabel = Schema.String.check(Schema.isLengthBetween(1, 500));
+var AgentReferenceLabel = Schema2.String.check(Schema2.isLengthBetween(1, 500));
 var AGENT_REFERENCE_LIMIT = 20;
-var AgentToolMetadata = Schema.Struct({
-  title: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  destructive: Schema.Boolean
+var AgentToolMetadata = Schema2.Struct({
+  title: Schema2.optional(Schema2.String),
+  description: Schema2.optional(Schema2.String),
+  destructive: Schema2.Boolean
 }).annotate({ identifier: "AgentToolMetadata" });
-var AgentEvent = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("message-start"),
-    messageId: Schema.String
+var AgentEvent = Schema2.Union([
+  Schema2.Struct({
+    type: Schema2.Literal("message-start"),
+    messageId: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("text-delta"),
-    messageId: Schema.String,
-    delta: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("text-delta"),
+    messageId: Schema2.String,
+    delta: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("tool-call"),
-    messageId: Schema.String,
-    toolCallId: Schema.String,
-    name: Schema.String,
-    input: Schema.Unknown,
+  Schema2.Struct({
+    type: Schema2.Literal("tool-call"),
+    messageId: Schema2.String,
+    toolCallId: Schema2.String,
+    name: Schema2.String,
+    input: Schema2.Unknown,
     metadata: AgentToolMetadata
   }),
-  Schema.Struct({
-    type: Schema.Literal("tool-result"),
-    toolCallId: Schema.String,
-    name: Schema.String,
-    isFailure: Schema.Boolean
+  Schema2.Struct({
+    type: Schema2.Literal("tool-result"),
+    toolCallId: Schema2.String,
+    name: Schema2.String,
+    isFailure: Schema2.Boolean
   }),
-  Schema.Struct({
-    type: Schema.Literal("approval-required"),
-    approvalId: Schema.String,
-    toolCallId: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("approval-required"),
+    approvalId: Schema2.String,
+    toolCallId: Schema2.String
   }),
-  Schema.Struct({
-    type: Schema.Literal("history"),
-    value: Schema.String
+  Schema2.Struct({
+    type: Schema2.Literal("history"),
+    value: Schema2.String
   }),
-  Schema.Struct({ type: Schema.Literal("finish") }),
-  Schema.Struct({
-    type: Schema.Literal("error"),
-    code: Schema.Literals(["unavailable", "invalid-request", "stream-failed"])
+  Schema2.Struct({ type: Schema2.Literal("finish") }),
+  Schema2.Struct({
+    type: Schema2.Literal("error"),
+    code: Schema2.Literals(["unavailable", "invalid-request", "stream-failed"])
   })
 ]).annotate({
   identifier: "AgentEvent",
   title: "Agent stream event",
   description: "An event emitted by the agent endpoint."
 });
-var AgentStreamError = Schema.Struct({
-  code: Schema.Literals(["unavailable", "stream-failed"])
+var AgentStreamError = Schema2.Struct({
+  code: Schema2.Literals(["unavailable", "stream-failed"])
 }).annotate({
   identifier: "AgentStreamError",
   title: "Agent stream error",
@@ -1891,16 +1895,13 @@ function AgentWidget({
     setInput("");
     setReferences([]);
     setReferencePickerOpen(false);
-    onSubmit({
+    const messageReferences = references.length > 0 ? references.map(({ label, resource }) => ({ label, resource })) : undefined;
+    const action = {
       type: "message",
       text,
-      ...references.length > 0 ? {
-        references: references.map(({ label, resource }) => ({
-          label,
-          resource
-        }))
-      } : {}
-    });
+      references: messageReferences
+    };
+    onSubmit(action);
   };
   const respondToApproval = (tool, approved) => {
     if (!tool.approvalId || state.pending)

package/dist/services/agent/index.d.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Stream } from "effect";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { LanguageModel, Tool, Toolkit } from "effect/unstable/ai";
 import type { AgentAction } from "./schema.js";
 export type AgentStreamOptions<Tools extends Record<string, Tool.Any>> = {
@@ -13,41 +13,41 @@ declare const AgentHistoryError_base: new <A extends Record<string, any> = {}>(a
 declare class AgentHistoryError extends AgentHistoryError_base {
 }
 declare const AgentService_base: Context.ServiceClass<AgentService, "AgentService", {
-    stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"message-start">;
-        readonly messageId: import("effect/Schema").String;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"text-delta">;
-        readonly messageId: import("effect/Schema").String;
-        readonly delta: import("effect/Schema").String;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"tool-call">;
-        readonly messageId: import("effect/Schema").String;
-        readonly toolCallId: import("effect/Schema").String;
-        readonly name: import("effect/Schema").String;
-        readonly input: import("effect/Schema").Unknown;
-        readonly metadata: import("effect/Schema").Struct<{
-            readonly title: import("effect/Schema").optional<import("effect/Schema").String>;
-            readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
-            readonly destructive: import("effect/Schema").Boolean;
+    stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"message-start">;
+        readonly messageId: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"text-delta">;
+        readonly messageId: Schema.String;
+        readonly delta: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly messageId: Schema.String;
+        readonly toolCallId: Schema.String;
+        readonly name: Schema.String;
+        readonly input: Schema.Unknown;
+        readonly metadata: Schema.Struct<{
+            readonly title: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+            readonly destructive: Schema.Boolean;
         }>;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"tool-result">;
-        readonly toolCallId: import("effect/Schema").String;
-        readonly name: import("effect/Schema").String;
-        readonly isFailure: import("effect/Schema").Boolean;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"approval-required">;
-        readonly approvalId: import("effect/Schema").String;
-        readonly toolCallId: import("effect/Schema").String;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"history">;
-        readonly value: import("effect/Schema").String;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"finish">;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly type: import("effect/Schema").Literal<"error">;
-        readonly code: import("effect/Schema").Literals<readonly ["unavailable", "invalid-request", "stream-failed"]>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly toolCallId: Schema.String;
+        readonly name: Schema.String;
+        readonly isFailure: Schema.Boolean;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"approval-required">;
+        readonly approvalId: Schema.String;
+        readonly toolCallId: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"history">;
+        readonly value: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"finish">;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.Literal<"error">;
+        readonly code: Schema.Literals<readonly ["unavailable", "invalid-request", "stream-failed"]>;
     }, "Type"> | {
         type: "history";
         value: string;
@@ -56,44 +56,44 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
         code: "stream-failed";
     } | {
         type: "finish";
-    }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | import("effect/SchemaError").SchemaError, LanguageModel.LanguageModel>;
+    }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | Schema.SchemaError, LanguageModel.LanguageModel>;
 }> & {
     readonly make: Effect.Effect<{
-        stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"message-start">;
-            readonly messageId: import("effect/Schema").String;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"text-delta">;
-            readonly messageId: import("effect/Schema").String;
-            readonly delta: import("effect/Schema").String;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"tool-call">;
-            readonly messageId: import("effect/Schema").String;
-            readonly toolCallId: import("effect/Schema").String;
-            readonly name: import("effect/Schema").String;
-            readonly input: import("effect/Schema").Unknown;
-            readonly metadata: import("effect/Schema").Struct<{
-                readonly title: import("effect/Schema").optional<import("effect/Schema").String>;
-                readonly description: import("effect/Schema").optional<import("effect/Schema").String>;
-                readonly destructive: import("effect/Schema").Boolean;
+        stream: <Tools extends Record<string, Tool.Any>>(args_0: AgentStreamOptions<Tools>) => Effect.Effect<Stream.Stream<Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"message-start">;
+            readonly messageId: Schema.String;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"text-delta">;
+            readonly messageId: Schema.String;
+            readonly delta: Schema.String;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"tool-call">;
+            readonly messageId: Schema.String;
+            readonly toolCallId: Schema.String;
+            readonly name: Schema.String;
+            readonly input: Schema.Unknown;
+            readonly metadata: Schema.Struct<{
+                readonly title: Schema.optional<Schema.String>;
+                readonly description: Schema.optional<Schema.String>;
+                readonly destructive: Schema.Boolean;
             }>;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"tool-result">;
-            readonly toolCallId: import("effect/Schema").String;
-            readonly name: import("effect/Schema").String;
-            readonly isFailure: import("effect/Schema").Boolean;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"approval-required">;
-            readonly approvalId: import("effect/Schema").String;
-            readonly toolCallId: import("effect/Schema").String;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"history">;
-            readonly value: import("effect/Schema").String;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"finish">;
-        }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-            readonly type: import("effect/Schema").Literal<"error">;
-            readonly code: import("effect/Schema").Literals<readonly ["unavailable", "invalid-request", "stream-failed"]>;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"tool-result">;
+            readonly toolCallId: Schema.String;
+            readonly name: Schema.String;
+            readonly isFailure: Schema.Boolean;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"approval-required">;
+            readonly approvalId: Schema.String;
+            readonly toolCallId: Schema.String;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"history">;
+            readonly value: Schema.String;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"finish">;
+        }, "Type"> | Schema.Struct.ReadonlySide<{
+            readonly type: Schema.Literal<"error">;
+            readonly code: Schema.Literals<readonly ["unavailable", "invalid-request", "stream-failed"]>;
         }, "Type"> | {
             type: "history";
             value: string;
@@ -102,7 +102,7 @@ declare const AgentService_base: Context.ServiceClass<AgentService, "AgentServic
             code: "stream-failed";
         } | {
             type: "finish";
-        }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | import("effect/SchemaError").SchemaError, LanguageModel.LanguageModel>;
+        }, never, Exclude<Tool.HandlerServices<Tools[keyof Tools]>, LanguageModel.LanguageModel> | Exclude<Tool.ResultDecodingServices<Tools[keyof Tools]>, LanguageModel.LanguageModel>>, AgentHistoryError | Schema.SchemaError, LanguageModel.LanguageModel>;
     }, never, never>;
 };
 export declare class AgentService extends AgentService_base {

package/dist/services/agent/index.js

@@ -1,5 +1,14 @@
 // ../../src/services/agent/index.ts
-import { Context, Data, Effect, Layer, Option, Ref, Stream } from "effect";
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Option,
+  Ref,
+  Schema,
+  Stream
+} from "effect";
 import {
   Chat,
   LanguageModel,
@@ -9,23 +18,30 @@ import {
 
 class AgentHistoryError extends Data.TaggedError("AgentHistoryError") {
 }
+var AgentStreamErrorDetails = Schema.Struct({
+  message: Schema.optional(Schema.String),
+  reason: Schema.optional(Schema.String),
+  status: Schema.optional(Schema.Number),
+  _tag: Schema.optional(Schema.String)
+}).annotate({ identifier: "AgentStreamErrorDetails" });
+var decodeAgentStreamErrorDetails = Schema.decodeUnknownOption(AgentStreamErrorDetails);
 
 class AgentService extends Context.Service()("AgentService", {
   make: Effect.gen(function* () {
     const streamErrorDetails = (error) => {
-      if (!error || typeof error !== "object") {
+      const details = Option.getOrUndefined(decodeAgentStreamErrorDetails(error));
+      if (!details)
         return { error: String(error) };
-      }
-      const message = Reflect.get(error, "message");
-      const reason = Reflect.get(error, "reason");
-      const status = Reflect.get(error, "status");
-      const tag = Reflect.get(error, "_tag");
-      return {
-        ...typeof message === "string" ? { message } : {},
-        ...typeof reason === "string" ? { reason } : {},
-        ...typeof status === "number" ? { status } : {},
-        ...typeof tag === "string" ? { tag } : {}
-      };
+      const result = {};
+      if (details.message)
+        result.message = details.message;
+      if (details.reason)
+        result.reason = details.reason;
+      if (details.status !== undefined)
+        result.status = details.status;
+      if (details._tag)
+        result.tag = details._tag;
+      return result;
     };
     const eventsForPart = ({
       messageId,
@@ -45,11 +61,14 @@ class AgentService extends Context.Service()("AgentService", {
               toolCallId: part.id,
               name: part.name,
               input: part.params,
-              metadata: {
-                ...title ? { title } : {},
-                ...tool?.description ? { description: tool.description } : {},
-                destructive: tool ? Context.get(tool.annotations, Tool.Destructive) : false
-              }
+              metadata: (() => {
+                const metadata = {
+                  destructive: tool ? Context.get(tool.annotations, Tool.Destructive) : false,
+                  title,
+                  description: tool?.description
+                };
+                return metadata;
+              })()
             }
           ];
         }
@@ -120,7 +139,7 @@ class AgentService extends Context.Service()("AgentService", {
       const resolvedToolCallIds = new Set;
       for (const message of history.content) {
         for (const part of message.content) {
-          if (typeof part === "string")
+          if (Schema.is(Schema.String)(part))
             continue;
           if (part.type === "tool-approval-request" && part.approvalId === action.approvalId) {
             pendingToolCallId = part.toolCallId;

package/dist/services/notification/channels/index.d.ts

@@ -1,22 +1,24 @@
 import { Context, Effect, Layer } from "effect";
+import type { Json } from "effect/Schema";
 import { NotificationSendError } from "../schema.js";
 export interface NotificationChannels {
 }
-export type NotificationMessage = keyof NotificationChannels extends never ? Record<string, unknown> : Partial<{
+export type NotificationMessage<FallbackPayload = Json> = keyof NotificationChannels extends never ? Record<string, FallbackPayload> : Partial<{
     readonly [Key in keyof NotificationChannels]: NotificationChannels[Key];
 }>;
-export interface NotificationChannelShape<Key extends string = string, Payload = unknown> {
+export interface NotificationChannel<Key extends string = string, Payload = Json> {
     readonly key: Key;
-    readonly send: (payload: unknown, message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
+    readonly send: (payload: Payload, message: NotificationMessage) => Effect.Effect<void, NotificationSendError>;
     readonly payload?: Payload;
 }
-export interface NotificationChannelRegistryShape {
-    readonly channels: ReadonlyArray<NotificationChannelShape>;
+export interface NotificationChannelRegistryService {
+    readonly channels: ReadonlyArray<NotificationChannel>;
 }
-declare const NotificationChannelRegistry_base: Context.ServiceClass<NotificationChannelRegistry, "NotificationChannelRegistry", NotificationChannelRegistryShape>;
+/** @deprecated Use the domain-owned names without the Shape suffix. */
+export { type NotificationChannel as NotificationChannelShape, type NotificationChannelRegistryService as NotificationChannelRegistryShape, };
+declare const NotificationChannelRegistry_base: Context.ServiceClass<NotificationChannelRegistry, "NotificationChannelRegistry", NotificationChannelRegistryService>;
 export declare class NotificationChannelRegistry extends NotificationChannelRegistry_base {
-    static readonly make: (...channels: ReadonlyArray<NotificationChannelShape>) => NotificationChannelRegistryShape;
-    static readonly layer: (channels: ReadonlyArray<NotificationChannelShape>) => Layer.Layer<NotificationChannelRegistry, never, never>;
+    static readonly make: (...channels: ReadonlyArray<NotificationChannel>) => NotificationChannelRegistryService;
+    static readonly layer: (channels: ReadonlyArray<NotificationChannel>) => Layer.Layer<NotificationChannelRegistry, never, never>;
     static readonly emptyLayer: Layer.Layer<NotificationChannelRegistry, never, never>;
 }
-export {};

package/dist/services/notification/channels/ses/index.d.ts

@@ -1,5 +1,5 @@
 import { Config, Context, Effect, Layer, Redacted } from "effect";
-import { type NotificationChannelShape } from "..";
+import { type NotificationChannel } from "..";
 import { SesEmailNotification } from "./schema.js";
 declare module ".." {
     interface NotificationChannels {
@@ -14,17 +14,17 @@ interface SesIdentity {
     readonly region: string;
     readonly from: string | undefined;
 }
-interface SesNotificationConfigShape {
+interface SesNotificationConfigService {
     readonly identity: SesIdentity;
     readonly accessKey: SesAccessKey;
 }
-declare const SesNotificationConfig_base: Context.ServiceClass<SesNotificationConfig, "SesNotificationConfig", SesNotificationConfigShape> & {
-    readonly make: Effect.Effect<SesNotificationConfigShape, Config.ConfigError, never>;
+declare const SesNotificationConfig_base: Context.ServiceClass<SesNotificationConfig, "SesNotificationConfig", SesNotificationConfigService> & {
+    readonly make: Effect.Effect<SesNotificationConfigService, Config.ConfigError, never>;
 };
 export declare class SesNotificationConfig extends SesNotificationConfig_base {
     static readonly layer: Layer.Layer<SesNotificationConfig, Config.ConfigError, never>;
 }
-declare const SesNotificationChannel_base: Context.ServiceClass<SesNotificationChannel, "SesNotificationChannel", NotificationChannelShape<"email", {
+declare const SesNotificationChannel_base: Context.ServiceClass<SesNotificationChannel, "SesNotificationChannel", NotificationChannel<"email", {
     readonly from?: string | undefined;
     readonly to: string | readonly [string, ...string[]];
     readonly cc?: readonly string[] | undefined;
@@ -34,7 +34,7 @@ declare const SesNotificationChannel_base: Context.ServiceClass<SesNotificationC
     readonly text?: string | undefined;
     readonly html?: string | undefined;
 }>> & {
-    readonly make: Effect.Effect<NotificationChannelShape<"email", {
+    readonly make: Effect.Effect<NotificationChannel<"email", {
         readonly from?: string | undefined;
         readonly to: string | readonly [string, ...string[]];
         readonly cc?: readonly string[] | undefined;

package/dist/services/notification/channels/ses/index.js

@@ -106,7 +106,7 @@ class SesNotificationChannel extends Context.Service()("SesNotificationChannel",
           FromEmailAddress: from,
           Destination: buildDestination(email),
           Content: { Simple: emailMessage },
-          ...email.replyTo?.length ? { ReplyToAddresses: Array.from(email.replyTo) } : {}
+          ReplyToAddresses: email.replyTo?.length ? Array.from(email.replyTo) : undefined
         })),
         catch: (error) => notificationSendError("Failed to send SES email", error)
       });
@@ -119,7 +119,7 @@ class SesNotificationChannel extends Context.Service()("SesNotificationChannel",
 var notificationSendError = (message, error) => new NotificationSendError({
   channel: "email",
   message,
-  ...error === undefined ? {} : { error }
+  error
 });
 var decodeEmail = (payload) => Schema3.decodeUnknownEffect(SesEmailNotification)(payload).pipe(Effect.mapError((error) => notificationSendError("Invalid SES email notification payload", error)));
 var requireBody = (email) => {
@@ -127,18 +127,22 @@ var requireBody = (email) => {
   if (!html && !text) {
     return Effect.fail(notificationSendError("SES email notification requires text or html"));
   }
-  const body = {
-    ...text ? { Text: { Data: text, Charset: "UTF-8" } } : {},
-    ...html ? { Html: { Data: html, Charset: "UTF-8" } } : {}
-  };
+  const body = {};
+  if (text)
+    body.Text = { Data: text, Charset: "UTF-8" };
+  if (html)
+    body.Html = { Data: html, Charset: "UTF-8" };
   return Effect.succeed(body);
 };
 var recipients = (to) => Array.isArray(to) ? Array.from(to) : [to];
-var buildDestination = (email) => ({
-  ToAddresses: recipients(email.to),
-  ...email.cc?.length ? { CcAddresses: Array.from(email.cc) } : {},
-  ...email.bcc?.length ? { BccAddresses: Array.from(email.bcc) } : {}
-});
+var buildDestination = (email) => {
+  const destination = { ToAddresses: recipients(email.to) };
+  if (email.cc?.length)
+    destination.CcAddresses = Array.from(email.cc);
+  if (email.bcc?.length)
+    destination.BccAddresses = Array.from(email.bcc);
+  return destination;
+};
 export {
   SesNotificationConfig,
   SesNotificationChannel

package/dist/services/notification/client/index.js

@@ -8,6 +8,7 @@ import {
   TriangleAlert
 } from "lucide-react";
 import { useState } from "react";
+import { Schema } from "effect";
 
 // ../../src/components/ui/badge.tsx
 import { mergeProps } from "@base-ui/react/merge-props";
@@ -974,7 +975,7 @@ function NotificationListItem({
       onNavigate(notification);
       return;
     }
-    if (notification.href && typeof window !== "undefined") {
+    if (notification.href && globalThis.window) {
       window.location.assign(notification.href);
     }
   };
@@ -1112,7 +1113,7 @@ var formatNotificationDate = (value, locale) => {
     timeStyle: "short"
   }).format(date);
 };
-var notificationTitle = (notification) => typeof notification.title === "string" ? notification.title : defaultMessages.en.notifications;
+var notificationTitle = (notification) => Schema.is(Schema.String)(notification.title) ? notification.title : defaultMessages.en.notifications;
 export {
   notificationMenuMessages,
   NotificationMenuTrigger,