agentic-notify 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,45 +1,45 @@
 import {
+  D1_SCHEMA,
   DeliveryError,
   PACKAGE_NAME,
   SIGNATURE_HEADER,
+  createD1Store,
   createDispatcher,
+  createMemoryStore,
   createWebhookChannel,
   signPayload,
   verifySignature
-} from "./chunk-6CKFBZOF.js";
+} from "./chunk-3N77SYRA.js";
 import {
   createEmailChannel
 } from "./chunk-KJKM56FT.js";
 import {
   CHANNELS,
-  D1Store,
   DEFAULT_CHANNELS,
   NotFoundError,
-  VERSION,
   createNotifier,
   defaultPreferences,
-  migrateD1,
   recipientKey
-} from "./chunk-FMU2ED2H.js";
+} from "./chunk-ARL7FN6Y.js";
 import {
-  MemoryStore
-} from "./chunk-GJFAXI2K.js";
+  VERSION
+} from "./chunk-PHY45IVQ.js";
 export {
   CHANNELS,
-  D1Store,
+  D1_SCHEMA,
   DEFAULT_CHANNELS,
   DeliveryError,
-  MemoryStore,
   NotFoundError,
   PACKAGE_NAME,
   SIGNATURE_HEADER,
   VERSION,
+  createD1Store,
   createDispatcher,
   createEmailChannel,
+  createMemoryStore,
   createNotifier,
   createWebhookChannel,
   defaultPreferences,
-  migrateD1,
   recipientKey,
   signPayload,
   verifySignature

package/dist/mcp-bin.js

@@ -1,19 +1,27 @@
 #!/usr/bin/env node
 import {
-  startMcp
-} from "./chunk-DEPJ3SHO.js";
-import "./chunk-6CKFBZOF.js";
-import {
-  createClient
-} from "./chunk-FJPEUDTG.js";
-import "./chunk-KJKM56FT.js";
-import "./chunk-FMU2ED2H.js";
-import "./chunk-GJFAXI2K.js";
+  VERSION
+} from "./chunk-PHY45IVQ.js";
 
 // src/mcp-bin.ts
-var { NOTIFY_URL, NOTIFY_TOKEN } = process.env;
-var client = NOTIFY_URL && NOTIFY_TOKEN ? createClient({ baseUrl: NOTIFY_URL, token: NOTIFY_TOKEN }) : void 0;
-startMcp(client).catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
+var HELP = `agentic-notify-mcp ${VERSION}
+Usage: agentic-notify-mcp [--help | --version]
+
+Runs the MCP server on stdio. An MCP client starts it.
+`;
+var flag = process.argv[2];
+if (flag === "--version" || flag === "-V") {
+  process.stdout.write(`${VERSION}
+`);
+} else if (flag === "--help" || flag === "-h") {
+  process.stdout.write(HELP);
+} else {
+  Promise.all([import("./mcp.js"), import("./sdk.js")]).then(([{ startMcp }, { createClient }]) => {
+    const { NOTIFY_URL, NOTIFY_TOKEN } = process.env;
+    const client = NOTIFY_URL && NOTIFY_TOKEN ? createClient({ baseUrl: NOTIFY_URL, token: NOTIFY_TOKEN }) : void 0;
+    return startMcp(client);
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}

package/dist/mcp.d.ts

@@ -1,8 +1,8 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Client } from './sdk.js';
-import './types-GuAgyMOc.js';
+import './types-anA8DMQH.js';
 import 'zod';
-import './gdpr-9I4eV86m.js';
+import './gdpr-BAg1U1w6.js';
 
 /** Without a client, only `ping` works and the other tools report that setup is missing. */
 declare function createMcpServer(client?: Client): McpServer;

package/dist/mcp.js

@@ -1,12 +1,87 @@
 import {
-  createMcpServer,
-  startMcp
-} from "./chunk-DEPJ3SHO.js";
-import "./chunk-6CKFBZOF.js";
-import "./chunk-FJPEUDTG.js";
+  PACKAGE_NAME
+} from "./chunk-3N77SYRA.js";
+import {
+  ApiError
+} from "./chunk-FJPEUDTG.js";
 import "./chunk-KJKM56FT.js";
-import "./chunk-FMU2ED2H.js";
-import "./chunk-GJFAXI2K.js";
+import {
+  preferencesSchema,
+  recipientSchema,
+  resourceRefSchema,
+  typeNameSchema
+} from "./chunk-ARL7FN6Y.js";
+import {
+  VERSION
+} from "./chunk-PHY45IVQ.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+async function wrap(fn) {
+  try {
+    return { content: [{ type: "text", text: JSON.stringify(await fn()) }] };
+  } catch (error) {
+    if (error instanceof ApiError) {
+      return { content: [{ type: "text", text: JSON.stringify({ error: error.code, status: error.status }) }], isError: true };
+    }
+    throw error;
+  }
+}
+function createMcpServer(client) {
+  const server = new McpServer({ name: PACKAGE_NAME, version: VERSION });
+  const need = (fn) => () => wrap(async () => {
+    if (!client) throw new ApiError(0, "not_configured");
+    return fn(client);
+  });
+  const read = { readOnlyHint: true };
+  const write = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+  server.registerTool(
+    "ping",
+    { description: "Check that the server runs. Returns the package version.", inputSchema: {}, annotations: read },
+    async () => ({ content: [{ type: "text", text: JSON.stringify({ ok: true, version: VERSION }) }] })
+  );
+  server.registerTool("list_notifications", {
+    description: "List your notifications, newest first.",
+    inputSchema: { unreadOnly: z.boolean().optional(), limit: z.number().int().min(1).max(200).optional(), cursor: z.string().optional() },
+    annotations: read
+  }, (a) => need((c) => c.list(a))());
+  server.registerTool(
+    "read_notification",
+    { description: "Get one notification by id.", inputSchema: { id: z.string() }, annotations: read },
+    ({ id }) => need((c) => c.get(id))()
+  );
+  server.registerTool(
+    "mark_read",
+    { description: "Mark one notification as read.", inputSchema: { id: z.string() }, annotations: write },
+    ({ id }) => need((c) => c.markRead(id))()
+  );
+  server.registerTool(
+    "mark_all_read",
+    { description: "Mark all your notifications as read.", inputSchema: {}, annotations: write },
+    need((c) => c.markAllRead())
+  );
+  server.registerTool(
+    "get_preferences",
+    { description: "Read your notification preferences.", inputSchema: {}, annotations: read },
+    need((c) => c.getPreferences())
+  );
+  server.registerTool("set_preferences", {
+    description: "Replace your notification preferences: channels per type, mute, muted types.",
+    inputSchema: preferencesSchema.shape,
+    annotations: write
+  }, (a) => need((c) => c.setPreferences(a))());
+  server.registerTool("send_notification", {
+    description: "Send a notification. You must hold the send right. You are the actor.",
+    inputSchema: { recipient: recipientSchema, type: typeNameSchema, resource: resourceRefSchema, body: z.string().max(2e3) },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  }, (a) => need((c) => c.send(a))());
+  return server;
+}
+async function startMcp(client) {
+  await createMcpServer(client).connect(new StdioServerTransport());
+}
 export {
   createMcpServer,
   startMcp

package/dist/sdk.d.ts

@@ -1,5 +1,5 @@
-import { N as Notification, D as Digest, P as Preferences, R as Recipient, a as ResourceRef } from './types-GuAgyMOc.js';
-import { R as RecipientExport } from './gdpr-9I4eV86m.js';
+import { N as Notification, D as Digest, P as Preferences, R as Recipient, a as ResourceRef } from './types-anA8DMQH.js';
+import { R as RecipientExport } from './gdpr-BAg1U1w6.js';
 import 'zod';
 
 declare class ApiError extends Error {
@@ -46,17 +46,17 @@ declare function createClient(options: ClientOptions): {
         type: string;
         id: string;
         recipient: {
-            id: string;
             kind: "human" | "agent";
+            id: string;
         };
         resource: {
-            id: string;
             kind: string;
+            id: string;
             url?: string | undefined;
         };
         actor: {
-            id: string;
             kind: "human" | "agent";
+            id: string;
         };
         body: string;
         createdAt: number;
@@ -66,17 +66,17 @@ declare function createClient(options: ClientOptions): {
         type: string;
         id: string;
         recipient: {
-            id: string;
             kind: "human" | "agent";
+            id: string;
         };
         resource: {
-            id: string;
             kind: string;
+            id: string;
             url?: string | undefined;
         };
         actor: {
-            id: string;
             kind: "human" | "agent";
+            id: string;
         };
         body: string;
         createdAt: number;

package/dist/{email-UqtllxjF.d.ts → testing-46doJP5Y.d.ts}

@@ -1,5 +1,6 @@
-import { R as Recipient } from './types-GuAgyMOc.js';
-import { D as DeliveryChannel } from './types-Dkst26cb.js';
+import 'agentic-identity/testing';
+import { R as Recipient } from './types-anA8DMQH.js';
+import { D as DeliveryChannel } from './types-BdX7UTFu.js';
 
 interface EmailMessage {
     to: string;

package/dist/testing.d.ts

@@ -1,13 +1,5 @@
-import { S as Store } from './types-Dkst26cb.js';
-export { T as TestEmailAdapter } from './email-UqtllxjF.js';
-import './types-GuAgyMOc.js';
+export { runStoreContract } from 'agentic-identity/testing';
+export { T as TestEmailAdapter } from './testing-46doJP5Y.js';
+import './types-anA8DMQH.js';
 import 'zod';
-
-/**
- * Contract suite for the Store port. Run it on every adapter.
- * `make` must return a fresh store. When two calls share one backing
- * database, the concurrency tests use both handles.
- */
-declare function storeContract(name: string, make: () => Promise<Store>, makePeer?: (s: Store) => Promise<Store>): void;
-
-export { storeContract };
+import './types-BdX7UTFu.js';

package/dist/testing.js

@@ -1,155 +1,10 @@
 import {
   TestEmailAdapter
 } from "./chunk-KJKM56FT.js";
-import {
-  encodeCursor
-} from "./chunk-GJFAXI2K.js";
 
 // src/testing.ts
-import { describe, expect, test } from "vitest";
-function storeContract(name, make, makePeer) {
-  describe(`Store contract: ${name}`, () => {
-    test("get returns null for a missing doc, put then get round-trips", async () => {
-      const s = await make();
-      expect(await s.get("c", "a")).toBeNull();
-      await s.put("c", "a", { n: 1, s: "x", t: true, z: null });
-      expect(await s.get("c", "a")).toEqual({ n: 1, s: "x", t: true, z: null });
-    });
-    test("collections are separate", async () => {
-      const s = await make();
-      await s.put("c1", "a", { v: 1 });
-      expect(await s.get("c2", "a")).toBeNull();
-    });
-    test("create refuses an existing id and keeps the old doc", async () => {
-      const s = await make();
-      expect(await s.create("c", "a", { v: 1 })).toBe(true);
-      expect(await s.create("c", "a", { v: 2 })).toBe(false);
-      expect(await s.get("c", "a")).toEqual({ v: 1 });
-    });
-    test("only one of two racing creates wins", async () => {
-      const s = await make();
-      const peer = makePeer ? await makePeer(s) : s;
-      const results = await Promise.all([s.create("c", "a", { v: 1 }), peer.create("c", "a", { v: 2 })]);
-      expect(results.filter(Boolean)).toHaveLength(1);
-    });
-    test("replaceIf swaps only when the doc is unchanged", async () => {
-      const s = await make();
-      await s.put("c", "a", { v: 1 });
-      expect(await s.replaceIf("c", "a", { v: 9 }, { v: 2 })).toBe(false);
-      expect(await s.replaceIf("c", "a", { v: 1 }, { v: 2 })).toBe(true);
-      expect(await s.get("c", "a")).toEqual({ v: 2 });
-      expect(await s.replaceIf("c", "missing", { v: 1 }, { v: 2 })).toBe(false);
-    });
-    test("replaceIf equality ignores key order", async () => {
-      const s = await make();
-      await s.put("c", "a", { a: 1, b: { x: 1, y: 2 } });
-      expect(await s.replaceIf("c", "a", { b: { y: 2, x: 1 }, a: 1 }, { a: 2 })).toBe(true);
-    });
-    test("only one of two racing replaceIf calls wins", async () => {
-      const s = await make();
-      const peer = makePeer ? await makePeer(s) : s;
-      await s.put("c", "a", { v: 0 });
-      const results = await Promise.all([
-        s.replaceIf("c", "a", { v: 0 }, { v: 1 }),
-        peer.replaceIf("c", "a", { v: 0 }, { v: 2 })
-      ]);
-      expect(results.filter(Boolean)).toHaveLength(1);
-    });
-    test("delete removes a doc and ignores a missing one", async () => {
-      const s = await make();
-      await s.put("c", "a", { v: 1 });
-      await s.delete("c", "a");
-      await s.delete("c", "a");
-      expect(await s.get("c", "a")).toBeNull();
-    });
-    test("query filters on equality, including null", async () => {
-      const s = await make();
-      await s.put("c", "a", { k: "x", r: null });
-      await s.put("c", "b", { k: "x", r: 5 });
-      await s.put("c", "c", { k: "y", r: null });
-      const ids = async (where) => (await s.query("c", { where, orderBy: { field: "k", direction: "asc" } })).items.map((i) => i.id).sort();
-      expect(await ids({ k: "x" })).toEqual(["a", "b"]);
-      expect(await ids({ k: "x", r: null })).toEqual(["a"]);
-      expect(await ids({ r: 5 })).toEqual(["b"]);
-      expect(await ids({ k: "none" })).toEqual([]);
-    });
-    test("equality filters respect the value type", async () => {
-      const s = await make();
-      await s.put("c", "t", { f: true, o: { a: 1 } });
-      await s.put("c", "u", { f: 1, o: '{"a":1}' });
-      await s.put("c", "v", { f: "1", o: [1] });
-      const ids = async (where) => (await s.query("c", { where })).items.map((i) => i.id).sort();
-      expect(await ids({ f: true })).toEqual(["t"]);
-      expect(await ids({ f: 1 })).toEqual(["u"]);
-      expect(await ids({ f: "1" })).toEqual(["v"]);
-      expect(await ids({ o: '{"a":1}' })).toEqual(["u"]);
-    });
-    test("query orders by one field and breaks ties by id", async () => {
-      const s = await make();
-      for (const [id, n] of [["b", 2], ["a", 2], ["c", 1], ["d", 3]]) await s.put("c", id, { n });
-      const order = async (direction) => (await s.query("c", { orderBy: { field: "n", direction } })).items.map((i) => i.id);
-      expect(await order("asc")).toEqual(["c", "a", "b", "d"]);
-      expect(await order("desc")).toEqual(["d", "b", "a", "c"]);
-    });
-    test("cursor paging walks every doc once, in both directions", async () => {
-      const s = await make();
-      for (let i = 0; i < 7; i++) await s.put("c", `id${i}`, { n: i % 3 });
-      for (const direction of ["asc", "desc"]) {
-        const seen = [];
-        let cursor;
-        let pages = 0;
-        do {
-          const page = await s.query("c", { orderBy: { field: "n", direction }, limit: 3, cursor });
-          seen.push(...page.items.map((i) => i.id));
-          cursor = page.nextCursor ?? void 0;
-          pages++;
-        } while (cursor);
-        const whole = (await s.query("c", { orderBy: { field: "n", direction }, limit: 50 })).items.map((i) => i.id);
-        expect(pages).toBe(3);
-        expect(seen).toEqual(whole);
-        expect(new Set(seen).size).toBe(7);
-      }
-    });
-    test("cursor paging works with a filter and with no orderBy", async () => {
-      const s = await make();
-      for (let i = 0; i < 6; i++) await s.put("c", `id${i}`, { g: i % 2 === 0 ? "even" : "odd", n: i });
-      const walk = async (query) => {
-        const seen = [];
-        let cursor;
-        do {
-          const page = await s.query("c", { ...query, limit: 2, cursor });
-          seen.push(...page.items.map((i) => i.id));
-          cursor = page.nextCursor ?? void 0;
-        } while (cursor);
-        return seen;
-      };
-      expect(await walk({ where: { g: "even" }, orderBy: { field: "n", direction: "desc" } })).toEqual(["id4", "id2", "id0"]);
-      expect(await walk({})).toEqual(["id0", "id1", "id2", "id3", "id4", "id5"]);
-    });
-    test("a cursor of the wrong type for the sort field is rejected", async () => {
-      const s = await make();
-      await s.put("c", "a", { n: 1 });
-      await s.put("c", "b", { n: 2 });
-      await expect(s.query("c", { orderBy: { field: "n", direction: "asc" }, cursor: encodeCursor("abc", "a") })).rejects.toThrow();
-    });
-    test("bad limit and bad cursor are rejected", async () => {
-      const s = await make();
-      await expect(s.query("c", { limit: 0 })).rejects.toThrow();
-      await expect(s.query("c", { cursor: "%%%" })).rejects.toThrow();
-    });
-    test("stored docs are copies", async () => {
-      const s = await make();
-      const doc = { nested: { v: 1 } };
-      await s.put("c", "a", doc);
-      doc.nested.v = 2;
-      const got = await s.get("c", "a");
-      expect(got.nested.v).toBe(1);
-      got.nested.v = 3;
-      expect((await s.get("c", "a")).nested.v).toBe(1);
-    });
-  });
-}
+import { runStoreContract } from "agentic-identity/testing";
 export {
   TestEmailAdapter,
-  storeContract
+  runStoreContract
 };

package/dist/types-BdX7UTFu.d.ts

@@ -0,0 +1,20 @@
+import { N as Notification } from './types-anA8DMQH.js';
+
+/** A delivery channel other than the inbox. */
+interface DeliveryChannel {
+    /** Resolves "skipped" when the recipient has no target (no endpoint, no address). Throws on failure. */
+    deliver(notification: Notification): Promise<"sent" | "skipped">;
+}
+declare class DeliveryError extends Error {
+    readonly attempts: number;
+    readonly code = "DELIVERY_FAILED";
+    constructor(message: string, attempts: number, options?: {
+        cause?: unknown;
+    });
+}
+/** Logger that takes ids and counts only. Never pass content or addresses. */
+interface Logger {
+    warn(message: string, fields?: Record<string, string | number>): void;
+}
+
+export { type DeliveryChannel as D, type Logger as L, DeliveryError as a };

package/dist/{types-GuAgyMOc.d.ts → types-anA8DMQH.d.ts}

@@ -6,11 +6,11 @@ declare const recipientSchema: z.ZodObject<{
     kind: z.ZodEnum<["human", "agent"]>;
     id: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    id: string;
     kind: "human" | "agent";
-}, {
     id: string;
+}, {
     kind: "human" | "agent";
+    id: string;
 }>;
 type Recipient = z.infer<typeof recipientSchema>;
 declare const resourceRefSchema: z.ZodObject<{
@@ -18,12 +18,12 @@ declare const resourceRefSchema: z.ZodObject<{
     id: z.ZodString;
     url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strict", z.ZodTypeAny, {
-    id: string;
     kind: string;
+    id: string;
     url?: string | undefined;
 }, {
-    id: string;
     kind: string;
+    id: string;
     url?: string | undefined;
 }>;
 type ResourceRef = z.infer<typeof resourceRefSchema>;
@@ -31,11 +31,11 @@ declare const actorSchema: z.ZodObject<{
     kind: z.ZodEnum<["human", "agent"]>;
     id: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    id: string;
     kind: "human" | "agent";
-}, {
     id: string;
+}, {
     kind: "human" | "agent";
+    id: string;
 }>;
 type Actor = z.infer<typeof actorSchema>;
 declare const notificationSchema: z.ZodObject<{
@@ -44,11 +44,11 @@ declare const notificationSchema: z.ZodObject<{
         kind: z.ZodEnum<["human", "agent"]>;
         id: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: "human" | "agent";
-    }, {
         id: string;
+    }, {
         kind: "human" | "agent";
+        id: string;
     }>;
     type: z.ZodString;
     resource: z.ZodObject<{
@@ -56,23 +56,23 @@ declare const notificationSchema: z.ZodObject<{
         id: z.ZodString;
         url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     }, {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     }>;
     actor: z.ZodObject<{
         kind: z.ZodEnum<["human", "agent"]>;
         id: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: "human" | "agent";
-    }, {
         id: string;
+    }, {
         kind: "human" | "agent";
+        id: string;
     }>;
     body: z.ZodString;
     createdAt: z.ZodNumber;
@@ -81,17 +81,17 @@ declare const notificationSchema: z.ZodObject<{
     type: string;
     id: string;
     recipient: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     resource: {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     };
     actor: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     body: string;
     createdAt: number;
@@ -100,17 +100,17 @@ declare const notificationSchema: z.ZodObject<{
     type: string;
     id: string;
     recipient: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     resource: {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     };
     actor: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     body: string;
     createdAt: number;
@@ -122,11 +122,11 @@ declare const sendInputSchema: z.ZodObject<{
         kind: z.ZodEnum<["human", "agent"]>;
         id: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: "human" | "agent";
-    }, {
         id: string;
+    }, {
         kind: "human" | "agent";
+        id: string;
     }>;
     type: z.ZodString;
     resource: z.ZodObject<{
@@ -134,55 +134,55 @@ declare const sendInputSchema: z.ZodObject<{
         id: z.ZodString;
         url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     }, {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     }>;
     actor: z.ZodObject<{
         kind: z.ZodEnum<["human", "agent"]>;
         id: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        id: string;
         kind: "human" | "agent";
-    }, {
         id: string;
+    }, {
         kind: "human" | "agent";
+        id: string;
     }>;
     body: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     type: string;
     recipient: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     resource: {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     };
     actor: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     body: string;
 }, {
     type: string;
     recipient: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     resource: {
-        id: string;
         kind: string;
+        id: string;
         url?: string | undefined;
     };
     actor: {
-        id: string;
         kind: "human" | "agent";
+        id: string;
     };
     body: string;
 }>;
@@ -214,4 +214,4 @@ interface Digest {
     groups: DigestGroup[];
 }
 
-export { type Actor as A, CHANNELS as C, type Digest as D, type Notification as N, type Preferences as P, type Recipient as R, type SendInput as S, type ResourceRef as a, type Channel as b, DEFAULT_CHANNELS as c, type DigestGroup as d, defaultPreferences as e, recipientKey as r };
+export { type Actor as A, type Channel as C, type Digest as D, type Notification as N, type Preferences as P, type Recipient as R, type SendInput as S, type ResourceRef as a, CHANNELS as b, DEFAULT_CHANNELS as c, type DigestGroup as d, defaultPreferences as e, recipientKey as r };