agentic-notify 0.0.0-stage → 0.1.0

package/dist/testing.js

@@ -0,0 +1,155 @@
+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);
+    });
+  });
+}
+export {
+  TestEmailAdapter,
+  storeContract
+};

package/dist/types-Dkst26cb.d.ts

@@ -0,0 +1,69 @@
+import { N as Notification } from './types-GuAgyMOc.js';
+
+/**
+ * Store port. Documents are flat JSON objects in named collections.
+ * The shape fits document stores and SQL alike: equality filters, one
+ * orderBy, a limit, cursor paging. No joins.
+ */
+type Scalar = string | number | boolean | null;
+type Doc = Record<string, unknown>;
+interface Query {
+    /** Equality filters on top-level scalar fields. */
+    where?: Record<string, Scalar>;
+    /** One sort field. Ties break by id, in the same direction. */
+    orderBy?: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+    limit?: number;
+    /** Opaque value from a previous page. */
+    cursor?: string;
+}
+interface Page {
+    items: {
+        id: string;
+        doc: Doc;
+    }[];
+    nextCursor: string | null;
+}
+interface Store {
+    get(collection: string, id: string): Promise<Doc | null>;
+    /** Insert or replace. */
+    put(collection: string, id: string, doc: Doc): Promise<void>;
+    /** Insert only. Returns false when the id exists. Atomic. */
+    create(collection: string, id: string, doc: Doc): Promise<boolean>;
+    /** Replace only when the stored doc still equals `expected`. Equality is structural: key order does not matter. Atomic. */
+    replaceIf(collection: string, id: string, expected: Doc, next: Doc): Promise<boolean>;
+    delete(collection: string, id: string): Promise<void>;
+    query(collection: string, query?: Query): Promise<Page>;
+}
+/** In-memory adapter. Also the reference for the contract suite. */
+declare class MemoryStore implements Store {
+    private readonly data;
+    private coll;
+    get(collection: string, id: string): Promise<Doc | null>;
+    put(collection: string, id: string, doc: Doc): Promise<void>;
+    create(collection: string, id: string, doc: Doc): Promise<boolean>;
+    replaceIf(collection: string, id: string, expected: Doc, next: Doc): Promise<boolean>;
+    delete(collection: string, id: string): Promise<void>;
+    query(collection: string, query?: Query): Promise<Page>;
+}
+
+/** 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, MemoryStore as M, type Page as P, type Query as Q, type Store as S, DeliveryError as a, type Doc as b, type Scalar as c };

package/dist/types-GuAgyMOc.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+
+declare const CHANNELS: readonly ["inbox", "webhook", "email"];
+type Channel = (typeof CHANNELS)[number];
+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";
+}>;
+type Recipient = z.infer<typeof recipientSchema>;
+declare const resourceRefSchema: z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    kind: string;
+    url?: string | undefined;
+}, {
+    id: string;
+    kind: string;
+    url?: string | undefined;
+}>;
+type ResourceRef = z.infer<typeof resourceRefSchema>;
+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";
+}>;
+type Actor = z.infer<typeof actorSchema>;
+declare const notificationSchema: z.ZodObject<{
+    id: z.ZodString;
+    recipient: z.ZodObject<{
+        kind: z.ZodEnum<["human", "agent"]>;
+        id: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: "human" | "agent";
+    }, {
+        id: string;
+        kind: "human" | "agent";
+    }>;
+    type: z.ZodString;
+    resource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    }, {
+        id: string;
+        kind: 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";
+    }>;
+    body: z.ZodString;
+    createdAt: z.ZodNumber;
+    readAt: z.ZodNullable<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    id: string;
+    recipient: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    resource: {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    };
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    body: string;
+    createdAt: number;
+    readAt: number | null;
+}, {
+    type: string;
+    id: string;
+    recipient: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    resource: {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    };
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    body: string;
+    createdAt: number;
+    readAt: number | null;
+}>;
+type Notification = z.infer<typeof notificationSchema>;
+declare const sendInputSchema: z.ZodObject<{
+    recipient: z.ZodObject<{
+        kind: z.ZodEnum<["human", "agent"]>;
+        id: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: "human" | "agent";
+    }, {
+        id: string;
+        kind: "human" | "agent";
+    }>;
+    type: z.ZodString;
+    resource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    }, {
+        id: string;
+        kind: 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";
+    }>;
+    body: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    recipient: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    resource: {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    };
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    body: string;
+}, {
+    type: string;
+    recipient: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    resource: {
+        id: string;
+        kind: string;
+        url?: string | undefined;
+    };
+    actor: {
+        id: string;
+        kind: "human" | "agent";
+    };
+    body: string;
+}>;
+type SendInput = z.infer<typeof sendInputSchema>;
+declare const preferencesSchema: z.ZodObject<{
+    channels: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodArray<z.ZodEnum<["inbox", "webhook", "email"]>, "many">, ("inbox" | "webhook" | "email")[], ("inbox" | "webhook" | "email")[]>>;
+    muted: z.ZodBoolean;
+    mutedTypes: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    channels: Record<string, ("inbox" | "webhook" | "email")[]>;
+    muted: boolean;
+    mutedTypes: string[];
+}, {
+    channels: Record<string, ("inbox" | "webhook" | "email")[]>;
+    muted: boolean;
+    mutedTypes: string[];
+}>;
+type Preferences = z.infer<typeof preferencesSchema>;
+declare const DEFAULT_CHANNELS: readonly Channel[];
+declare function defaultPreferences(): Preferences;
+declare function recipientKey(recipient: Recipient): string;
+interface DigestGroup {
+    type: string;
+    count: number;
+    latest: Notification;
+}
+interface Digest {
+    total: number;
+    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 };

package/dist/worker.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { e as Notifier, g as createDispatcher, D as D1Like } from './d1-CUcNko0m.js';
+import { R as Recipient } from './types-GuAgyMOc.js';
+import './gdpr-9I4eV86m.js';
+import './types-Dkst26cb.js';
+
+/** Who is calling. `kind` has no default: a missing kind is an error. */
+declare const principalSchema: z.ZodObject<{
+    kind: z.ZodEnum<["human", "agent"]>;
+    id: z.ZodString;
+    /** Allowed to send notifications to others. */
+    canSend: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    kind: "human" | "agent";
+    canSend?: boolean | undefined;
+}, {
+    id: string;
+    kind: "human" | "agent";
+    canSend?: boolean | undefined;
+}>;
+type Principal = z.infer<typeof principalSchema>;
+/** Port: turn a request into a principal, or null for "not signed in". Plug in any identity system. */
+type PrincipalResolver = (request: Request) => Promise<Principal | null> | Principal | null;
+
+interface AppOptions {
+    notifier: Notifier;
+    /** When set, sends also go to webhook and email channels. */
+    dispatcher?: ReturnType<typeof createDispatcher>;
+    resolvePrincipal: PrincipalResolver;
+    /** May this principal send to this recipient? Default: only principals with `canSend: true`. */
+    authorizeSend?: (principal: Principal, recipient: Recipient) => Promise<boolean> | boolean;
+}
+
+interface WorkerEnv {
+    NOTIFY_NAME?: string;
+    /** D1 binding. */
+    DB?: D1Like;
+    /** Secret. JSON map of bearer token (32 bytes or more) to principal. */
+    NOTIFY_TOKENS?: string;
+    /** Retention window in days. Unset keeps notifications. */
+    NOTIFY_RETENTION_DAYS?: string;
+}
+interface WorkerConfig {
+    /** Build the principal resolver from the environment. Null means not configured. */
+    resolver(env: WorkerEnv): Promise<PrincipalResolver | null>;
+    authorizeSend?: AppOptions["authorizeSend"];
+}
+/** Compose the Worker. Bring your own identity system through `resolver`. */
+declare function createWorker(config: WorkerConfig): {
+    fetch(request: Request, env: WorkerEnv): Promise<Response>;
+    /** Delete notifications past the retention window. Wire to a cron trigger. */
+    scheduled(_event: unknown, env: WorkerEnv): Promise<void>;
+};
+declare const _default: {
+    fetch(request: Request, env: WorkerEnv): Promise<Response>;
+    /** Delete notifications past the retention window. Wire to a cron trigger. */
+    scheduled(_event: unknown, env: WorkerEnv): Promise<void>;
+};
+
+export { type WorkerConfig, type WorkerEnv, createWorker, _default as default };

package/dist/worker.js

@@ -0,0 +1,170 @@
+import {
+  D1Store,
+  NotFoundError,
+  VERSION,
+  createNotifier,
+  migrateD1,
+  preferencesSchema,
+  recipientSchema,
+  resourceRefSchema,
+  typeNameSchema
+} from "./chunk-FMU2ED2H.js";
+import "./chunk-GJFAXI2K.js";
+
+// src/api.ts
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { ZodError, z as z2 } from "zod";
+
+// src/auth.ts
+import { z } from "zod";
+var principalSchema = z.object({
+  kind: z.enum(["human", "agent"]),
+  id: z.string().min(1).max(200),
+  /** Allowed to send notifications to others. */
+  canSend: z.boolean().optional()
+}).strict();
+var MIN_TOKEN_BYTES = 32;
+var enc = new TextEncoder();
+async function digest(token) {
+  const d = await crypto.subtle.digest("SHA-256", enc.encode(token));
+  return [...new Uint8Array(d)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function createStaticTokenResolver(tokens) {
+  const byDigest = /* @__PURE__ */ new Map();
+  for (const [token, principal] of Object.entries(tokens)) {
+    if (enc.encode(token).length < MIN_TOKEN_BYTES) throw new Error(`tokens must hold at least ${MIN_TOKEN_BYTES} bytes`);
+    byDigest.set(await digest(token), principalSchema.parse(principal));
+  }
+  if (byDigest.size === 0) throw new Error("no tokens configured");
+  return async (request) => {
+    const m = /^Bearer ([^\s]+)$/.exec(request.headers.get("authorization") ?? "");
+    return m ? byDigest.get(await digest(m[1])) ?? null : null;
+  };
+}
+
+// src/api.ts
+var sendBody = z2.object({ recipient: recipientSchema, type: typeNameSchema, resource: resourceRefSchema, body: z2.string().max(2e3) }).strict();
+var num = z2.coerce.number().int().nonnegative();
+function createApp(options) {
+  const { notifier } = options;
+  const authorizeSend = options.authorizeSend ?? ((p) => p.canSend === true);
+  const app = new Hono();
+  app.get("/health", (c) => c.json({ ok: true }));
+  const api = new Hono();
+  api.use("*", bodyLimit({ maxSize: 64 * 1024, onError: (c) => c.json({ error: "too_large" }, 413) }));
+  api.use("*", async (c, next) => {
+    const raw = await options.resolvePrincipal(c.req.raw);
+    const parsed = principalSchema.safeParse(raw);
+    if (!parsed.success) return c.json({ error: "unauthorized" }, 401);
+    c.set("principal", parsed.data);
+    c.set("me", { kind: parsed.data.kind, id: parsed.data.id });
+    await next();
+  });
+  async function json2(c) {
+    try {
+      return await c.req.json();
+    } catch {
+      throw new ZodError([{ code: "custom", path: [], message: "body must be JSON" }]);
+    }
+  }
+  api.get("/notifications", async (c) => {
+    const q = c.req.query();
+    const limit = q.limit === void 0 ? void 0 : z2.coerce.number().int().min(1).parse(q.limit);
+    try {
+      return c.json(await notifier.list(c.var.me, { unreadOnly: q.unread === "1" || q.unread === "true", limit, cursor: q.cursor }));
+    } catch (error) {
+      if (error instanceof RangeError) throw new ZodError([{ code: "custom", path: ["cursor"], message: "bad cursor" }]);
+      throw error;
+    }
+  });
+  api.post("/notifications", async (c) => {
+    const input = sendBody.parse(await json2(c));
+    if (!await authorizeSend(c.var.principal, input.recipient)) return c.json({ error: "forbidden" }, 403);
+    const full = { ...input, actor: c.var.me };
+    if (options.dispatcher) return c.json(await options.dispatcher.notify(full), 201);
+    const sent = await notifier.send(full);
+    const deliveries = sent.channels.filter((channel) => channel !== "inbox").map((channel) => ({ channel, ok: false, skipped: "no_channel" }));
+    return c.json({ ...sent, deliveries }, 201);
+  });
+  api.post("/notifications/read-all", async (c) => c.json({ marked: await notifier.markAllRead(c.var.me) }));
+  api.get("/notifications/:id", async (c) => c.json(await notifier.get(c.var.me, c.req.param("id"))));
+  api.post("/notifications/:id/read", async (c) => c.json(await notifier.markRead(c.var.me, c.req.param("id"))));
+  api.get("/unread-count", async (c) => c.json({ count: await notifier.unreadCount(c.var.me) }));
+  api.get("/digest", async (c) => {
+    const since = c.req.query("since");
+    return c.json(await notifier.digest(c.var.me, since === void 0 ? 0 : num.parse(since)));
+  });
+  api.get("/preferences", async (c) => c.json(await notifier.getPreferences(c.var.me)));
+  api.put("/preferences", async (c) => c.json(await notifier.setPreferences(c.var.me, preferencesSchema.parse(await json2(c)))));
+  api.get("/me/export", async (c) => c.json(await notifier.exportData(c.var.me)));
+  api.delete("/me", async (c) => c.json(await notifier.erase(c.var.me)));
+  app.route("/api/v1", api);
+  app.notFound((c) => c.json({ error: "not_found" }, 404));
+  app.onError((error, c) => {
+    if (error instanceof NotFoundError) return c.json({ error: "not_found" }, 404);
+    if (error instanceof ZodError) {
+      return c.json({ error: "invalid_request", issues: error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) }, 400);
+    }
+    console.error("internal error", error instanceof Error ? error.name : "unknown");
+    return c.json({ error: "internal_error" }, 500);
+  });
+  return app;
+}
+
+// src/worker.ts
+function json(value, status = 200) {
+  return new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } });
+}
+function createWorker(config) {
+  const apps = /* @__PURE__ */ new WeakMap();
+  async function buildNotifier(env) {
+    if (!env.DB) return null;
+    await migrateD1(env.DB);
+    const days = env.NOTIFY_RETENTION_DAYS === void 0 ? void 0 : Number(env.NOTIFY_RETENTION_DAYS);
+    return createNotifier({
+      store: new D1Store(env.DB),
+      retentionMs: days === void 0 ? void 0 : days * 864e5
+    });
+  }
+  async function build(env) {
+    const resolvePrincipal = await config.resolver(env);
+    const notifier = resolvePrincipal ? await buildNotifier(env) : null;
+    if (!resolvePrincipal || !notifier) return null;
+    return createApp({ notifier, resolvePrincipal, authorizeSend: config.authorizeSend });
+  }
+  return {
+    async fetch(request, env) {
+      const url = new URL(request.url);
+      if ((request.method === "GET" || request.method === "HEAD") && url.pathname === "/health") {
+        return json({ ok: true, name: env.NOTIFY_NAME ?? "agentic-notify", version: VERSION });
+      }
+      if (!url.pathname.startsWith("/api/")) return json({ error: "not_found" }, 404);
+      let app;
+      try {
+        let p = apps.get(env);
+        if (!p) apps.set(env, p = build(env));
+        app = await p;
+      } catch {
+        apps.delete(env);
+        return json({ error: "not_configured" }, 503);
+      }
+      if (!app) return json({ error: "not_configured" }, 503);
+      return app.fetch(request);
+    },
+    /** Delete notifications past the retention window. Wire to a cron trigger. */
+    async scheduled(_event, env) {
+      await (await buildNotifier(env))?.sweep();
+    }
+  };
+}
+var worker_default = createWorker({
+  async resolver(env) {
+    if (!env.NOTIFY_TOKENS) return null;
+    return createStaticTokenResolver(JSON.parse(env.NOTIFY_TOKENS));
+  }
+});
+export {
+  createWorker,
+  worker_default as default
+};