cursedbelt-server 4.26.1 → 4.28.0

package/dist/server/activity/store.js

@@ -1,170 +1,39 @@
-import { isActivityAction, isActivityOutcome, } from "cursedbelt-core/activity/model";
 import { runMigrations } from "../migration/runner.js";
-import { ACTIVITY_EVENTS_TABLE, ACTIVITY_MIGRATIONS } from "./migrations.js";
-const DEFAULT_LIMIT = 100;
-const MAX_LIMIT = 1000;
-const MAX_FACET = 25;
-/** `%` and `_` are wildcards and `\` is the escape — a note containing any of
- *  them must still search literally. */
-const likeContains = (value) => `%${value.replace(/[\\%_]/g, (ch) => `\\${ch}`)}%`;
-const toEvent = (row) => ({
-    id: `${row.source}:${row.seq}`,
-    source: row.source,
-    at: row.at,
-    app: row.app,
-    actor: row.actor,
-    action: row.action,
-    resource: row.kind === null || row.resource_id === null
-        ? null
-        : { app: row.app, kind: row.kind, id: row.resource_id },
-    outcome: isActivityOutcome(row.outcome) ? row.outcome : "ok",
-    note: row.note ?? "",
-    data: parseData(row.data),
-});
-/** A row whose `data` is unreadable must not take the page down with it — the
- *  event still says who did what, which is the part that matters. */
-function parseData(raw) {
-    if (!raw)
-        return null;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : { value: parsed };
-    }
-    catch {
-        return { unparsed: raw };
-    }
-}
+import { ACTIVITY_MIGRATIONS } from "./migrations.js";
+import { ACTIVITY_SQL, buildStream, facetLimit, MAX_FACET, pageLimit, prepareRecord, toStreamEvent, } from "./query.js";
 export function createActivityLog(options) {
     const { db, app } = options;
     const now = options.now ?? (() => new Date().toISOString());
     const registered = options.sources ?? [];
     runMigrations(db, ACTIVITY_MIGRATIONS);
-    const insert = db.query(`INSERT INTO ${ACTIVITY_EVENTS_TABLE}
-		   (at, app, actor, action, kind, resource_id, outcome, note, data)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-    const tableExists = (name) => !!db
-        .query("SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?")
-        .get(name);
+    const insert = db.query(ACTIVITY_SQL.insert);
+    const tableExists = (name) => !!db.query(ACTIVITY_SQL.tableExists).get(name);
     /** The contributors that can actually answer right now. */
     const liveSources = () => registered.filter((source) => !source.requiresTable || tableExists(source.requiresTable));
-    const OWN_SELECT = `SELECT 'log' AS source, event_id AS seq, at, app, actor, action,
-	                           kind, resource_id, outcome, note, data
-	                      FROM ${ACTIVITY_EVENTS_TABLE}`;
-    /** The union, plus the WHERE the caller asked for, plus their parameters in
-     *  bind order (sources first — they are inside the FROM). */
-    const stream = (query) => {
-        const params = [];
-        const selects = [OWN_SELECT];
-        for (const source of liveSources()) {
-            if (query.source && query.source !== source.name)
-                continue;
-            selects.push(source.sql);
-            params.push(...(source.params ?? []));
-        }
-        const where = [];
-        if (query.source) {
-            where.push("source = ?");
-            params.push(query.source);
-        }
-        if (query.since) {
-            where.push("at >= ?");
-            params.push(query.since);
-        }
-        if (query.until) {
-            where.push("at <= ?");
-            params.push(query.until);
-        }
-        if (query.actor) {
-            where.push("LOWER(actor) = LOWER(?)");
-            params.push(query.actor);
-        }
-        if (query.action) {
-            if (query.action.endsWith(".")) {
-                where.push("action LIKE ? ESCAPE '\\'");
-                params.push(`${query.action.replace(/[\\%_]/g, (ch) => `\\${ch}`)}%`);
-            }
-            else {
-                where.push("action = ?");
-                params.push(query.action);
-            }
-        }
-        if (query.kind) {
-            where.push("kind = ?");
-            params.push(query.kind);
-        }
-        if (query.resourceId) {
-            where.push("resource_id = ?");
-            params.push(query.resourceId);
-        }
-        if (query.outcome) {
-            where.push("outcome = ?");
-            params.push(query.outcome);
-        }
-        if (query.q) {
-            where.push("(actor LIKE ? ESCAPE '\\' OR action LIKE ? ESCAPE '\\' OR note LIKE ? ESCAPE '\\' OR IFNULL(resource_id, '') LIKE ? ESCAPE '\\')");
-            const like = likeContains(query.q);
-            params.push(like, like, like, like);
-        }
-        // `query.source` naming a contributor that is not live leaves only the own
-        // select, filtered to a source it cannot be — an empty result, which is the
-        // honest answer rather than every row.
-        const sql = `SELECT * FROM (${selects.join("\n UNION ALL\n")}) AS stream${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`;
-        return { sql, params };
-    };
+    const stream = (query) => buildStream(query, liveSources());
     return {
         app,
         record(input) {
-            if (!isActivityAction(input.action)) {
-                throw new Error(`activity: "${input.action}" is not an action — use lowercase subject.verb, e.g. "backup.delete"`);
-            }
-            const actor = input.actor?.trim();
-            if (!actor) {
-                // An event that cannot say who is a log line, not an audit trail.
-                throw new Error(`activity: ${input.action} has no actor`);
-            }
-            const at = input.at ?? now();
-            const outcome = input.outcome ?? "ok";
-            const data = input.data ? JSON.stringify(input.data) : null;
-            const info = insert.run(at, app, actor, input.action, input.resource?.kind ?? null, input.resource?.id ?? null, outcome, input.note ?? "", data);
-            return {
-                id: `log:${Number(info.lastInsertRowid)}`,
-                source: "log",
-                at,
-                app,
-                actor,
-                action: input.action,
-                resource: input.resource ? { app, ...input.resource } : null,
-                outcome,
-                note: input.note ?? "",
-                data: input.data ?? null,
-            };
+            const { binds, event } = prepareRecord(app, input, now);
+            const info = insert.run(...binds);
+            return { id: `log:${Number(info.lastInsertRowid)}`, ...event };
         },
         query(query = {}) {
-            const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DEFAULT_LIMIT)));
+            const limit = pageLimit(query.limit);
             const { sql, params } = stream(query);
-            // One row past the limit, so "there is more" is a fact rather than a
-            // guess made from `rows.length === limit`.
-            const rows = db
-                .query(`${sql} ORDER BY at DESC, seq DESC LIMIT ?`)
-                .all(...params, limit + 1);
+            const rows = db.query(ACTIVITY_SQL.page(sql)).all(...params, limit + 1);
             const truncated = rows.length > limit;
-            return { events: rows.slice(0, limit).map(toEvent), limit, truncated };
+            return { events: rows.slice(0, limit).map(toStreamEvent), limit, truncated };
         },
         count(query = {}) {
             const { sql, params } = stream(query);
-            const row = db.query(`SELECT COUNT(*) AS n FROM (${sql})`).get(...params);
+            const row = db.query(ACTIVITY_SQL.count(sql)).get(...params);
             return row?.n ?? 0;
         },
         facets(query = {}, limit = MAX_FACET) {
             const { sql, params } = stream(query);
-            const capped = Math.min(MAX_FACET, Math.max(1, Math.floor(limit)));
-            const dimension = (column) => db
-                .query(`SELECT ${column} AS value, COUNT(*) AS count FROM (${sql})
-							  WHERE ${column} IS NOT NULL AND ${column} <> ''
-							  GROUP BY ${column} ORDER BY count DESC, value ASC LIMIT ?`)
-                .all(...params, capped).map((row) => ({ value: row.value, count: row.count }));
+            const capped = facetLimit(limit);
+            const dimension = (column) => db.query(ACTIVITY_SQL.facet(sql, column)).all(...params, capped).map((row) => ({ value: row.value, count: row.count }));
             return {
                 actions: dimension("action"),
                 actors: dimension("actor"),

package/dist/server/engagement/d1.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `cursedbelt-server/engagement/d1` — the engagement recorder over D1, for an app a Worker serves.
+ *
+ * ── Why it exists ───────────────────────────────────────────────────────────
+ * `./engagement` is Bun-only: its store is a synchronous `bun:sqlite` file (`engagement.sqlite`)
+ * that station's Metrics page reads off disk. A Worker has neither, so an app that moved to one
+ * stopped being heard with no error anywhere — `collections` from its 2026-09-22 cutover until
+ * this subpath (task 2096). The SAME three tables live in the app's own D1 instead (its
+ * `db/schema.sql`, from {@link ENGAGEMENT_DDL}), written with the SAME fold (`./policy.ts` →
+ * `foldView`, `dayKey`, `resolvePlace`), and station reads them from D1 for any Worker-served app.
+ *
+ * It was `apps/music/src/server/engagementD1.ts` plus a copied `kit/engagement/policy.ts` held
+ * byte-identical by a parity test (task 2081). collections was the second consumer, so it was
+ * lifted here rather than copied again — and the policy copy went with it: this module imports
+ * the library's own `policy.ts`, so there is one privacy rule, not one per Worker.
+ *
+ * 🔴 Worker-safe: nothing reachable from here at runtime imports `bun:*`
+ * (`telemetryIsWorkerSafe.spec.ts` walks it). Do not import `./store.js` or `./api.js` here.
+ *
+ * 🔴 The kit's privacy story holds unchanged: the place is resolved against the app's own route
+ * manifest AT THE DOOR, so an id, an album name or a search string never reaches a row; the
+ * account is the session's subject, never anything in the body. Mount it INSIDE the session gate.
+ *
+ * 🔴 {@link ENGAGEMENT_DDL} must stay byte-identical in effect to `EngagementStore`'s `migrate()` —
+ * station reads both shapes with one query set. `d1.spec.ts` builds both and compares their
+ * `sqlite_master` rows, so a column added to one and not the other is a red.
+ *
+ * ```ts
+ * import { createD1EngagementRecorder, placesFromManifest } from "cursedbelt-server/engagement/d1";
+ * import routesManifest from "../routes.manifest.json";
+ *
+ * gated.route("/api/engagement", createD1EngagementRecorder({
+ *   db, places: placesFromManifest(routesManifest), resolveUser: (c) => sso.userOf(c)?.id ?? null,
+ * }));
+ * ```
+ */
+import type { D1LikeDatabase } from "../d1/types.js";
+import type { Context } from "hono";
+import { Hono } from "hono";
+import { type PlaceRef } from "./policy.js";
+/** The kit store's own tables and indexes, as one-line DDL — see the header. */
+export declare const ENGAGEMENT_DDL: readonly string[];
+/**
+ * Record one view — the kit's `EngagementStore.recordView`, asynchronously: one read (the
+ * account's previous view) and ONE batch of up to five statements, so a view is atomic and
+ * costs two D1 round trips however much it credits.
+ */
+export declare function recordViewD1(db: D1LikeDatabase, input: {
+    userKey: string;
+    place: string;
+    ts: number;
+}): Promise<{
+    newSession: boolean;
+    activeMs: number;
+}>;
+/**
+ * The recorder as the kit's `createEngagementRecorder` mounts it — `POST /view` under
+ * `ENGAGEMENT_BASE_PATH` — over D1. Recording only: there is no read surface here, as there is
+ * none on the Mac; station reads the tables directly.
+ */
+export declare function createD1EngagementRecorder(options: {
+    db: D1LikeDatabase;
+    places: readonly PlaceRef[];
+    resolveUser: (c: Context) => string | null;
+    now?: () => number;
+}): Hono;
+export { placesFromManifest } from "./manifestPlaces.js";

package/dist/server/engagement/d1.js

@@ -0,0 +1,81 @@
+import { Hono } from "hono";
+import { dayKey, foldView, OTHER_PLACE, resolvePlace } from "./policy.js";
+/** The kit store's own tables and indexes, as one-line DDL — see the header. */
+export const ENGAGEMENT_DDL = [
+    "CREATE TABLE IF NOT EXISTS engagement_days ( user_key TEXT NOT NULL, place TEXT NOT NULL, day TEXT NOT NULL, views INTEGER NOT NULL DEFAULT 0, active_ms INTEGER NOT NULL DEFAULT 0, sessions INTEGER NOT NULL DEFAULT 0, first_ts INTEGER NOT NULL, last_ts INTEGER NOT NULL, PRIMARY KEY (user_key, place, day) )",
+    "CREATE INDEX IF NOT EXISTS idx_engagement_days_day ON engagement_days (day)",
+    "CREATE TABLE IF NOT EXISTS engagement_places ( user_key TEXT NOT NULL, place TEXT NOT NULL, views INTEGER NOT NULL DEFAULT 0, sessions INTEGER NOT NULL DEFAULT 0, active_ms INTEGER NOT NULL DEFAULT 0, first_ts INTEGER NOT NULL, last_ts INTEGER NOT NULL, PRIMARY KEY (user_key, place) )",
+    "CREATE INDEX IF NOT EXISTS idx_engagement_places_last ON engagement_places (last_ts)",
+    "CREATE TABLE IF NOT EXISTS engagement_users ( user_key TEXT PRIMARY KEY, views INTEGER NOT NULL DEFAULT 0, sessions INTEGER NOT NULL DEFAULT 0, active_ms INTEGER NOT NULL DEFAULT 0, first_ts INTEGER NOT NULL, last_ts INTEGER NOT NULL, last_place TEXT NOT NULL DEFAULT '' )",
+];
+/**
+ * Record one view — the kit's `EngagementStore.recordView`, asynchronously: one read (the
+ * account's previous view) and ONE batch of up to five statements, so a view is atomic and
+ * costs two D1 round trips however much it credits.
+ */
+export async function recordViewD1(db, input) {
+    const { userKey, place, ts } = input;
+    const prior = await db
+        .prepare("SELECT last_ts, last_place FROM engagement_users WHERE user_key = ?")
+        .bind(userKey)
+        .first();
+    const fold = foldView(prior ? prior.last_ts : null, ts);
+    const sessionDelta = fold.newSession ? 1 : 0;
+    const statements = [];
+    if (fold.activeMs > 0 && prior?.last_place) {
+        // The time since the last view is credited to the place the account was LOOKING AT.
+        statements.push(db
+            .prepare("UPDATE engagement_days SET active_ms = active_ms + ? WHERE user_key = ? AND place = ? AND day = ?")
+            .bind(fold.activeMs, userKey, prior.last_place, dayKey(prior.last_ts)), db
+            .prepare("UPDATE engagement_places SET active_ms = active_ms + ? WHERE user_key = ? AND place = ?")
+            .bind(fold.activeMs, userKey, prior.last_place));
+    }
+    statements.push(db
+        .prepare(`INSERT INTO engagement_days (user_key, place, day, views, active_ms, sessions, first_ts, last_ts)
+				 VALUES (?, ?, ?, 1, 0, ?, ?, ?)
+				 ON CONFLICT(user_key, place, day) DO UPDATE SET
+				   views = views + 1, sessions = sessions + excluded.sessions, last_ts = excluded.last_ts`)
+        .bind(userKey, place, dayKey(ts), sessionDelta, ts, ts), db
+        .prepare(`INSERT INTO engagement_places (user_key, place, views, sessions, active_ms, first_ts, last_ts)
+				 VALUES (?, ?, 1, ?, 0, ?, ?)
+				 ON CONFLICT(user_key, place) DO UPDATE SET
+				   views = views + 1, sessions = sessions + excluded.sessions, last_ts = excluded.last_ts`)
+        .bind(userKey, place, sessionDelta, ts, ts), db
+        .prepare(`INSERT INTO engagement_users (user_key, views, sessions, active_ms, first_ts, last_ts, last_place)
+				 VALUES (?, 1, ?, 0, ?, ?, ?)
+				 ON CONFLICT(user_key) DO UPDATE SET
+				   views = views + 1, sessions = sessions + excluded.sessions, active_ms = active_ms + ?,
+				   last_ts = excluded.last_ts, last_place = excluded.last_place`)
+        .bind(userKey, sessionDelta, ts, ts, place, fold.activeMs));
+    await db.batch(statements);
+    return fold;
+}
+/**
+ * The recorder as the kit's `createEngagementRecorder` mounts it — `POST /view` under
+ * `ENGAGEMENT_BASE_PATH` — over D1. Recording only: there is no read surface here, as there is
+ * none on the Mac; station reads the tables directly.
+ */
+export function createD1EngagementRecorder(options) {
+    const app = new Hono();
+    const now = options.now ?? (() => Date.now());
+    app.post("/view", async (c) => {
+        const userKey = options.resolveUser(c);
+        if (!userKey)
+            return c.json({ error: "unauthenticated" }, 401);
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "expected a json body" }, 400);
+        }
+        const claimed = body?.place;
+        if (typeof claimed !== "string")
+            return c.json({ error: "place must be a string" }, 400);
+        const place = resolvePlace(claimed, options.places);
+        const fold = await recordViewD1(options.db, { userKey, place, ts: now() });
+        return c.json({ ok: true, place, bucketed: place === OTHER_PLACE, ...fold });
+    });
+    return app;
+}
+export { placesFromManifest } from "./manifestPlaces.js";

package/dist/server/engagement/manifestPlaces.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A parsed `routes.manifest.json` → the place allowlist. Pure, and Worker-safe: `places.ts`
+ * reads the file off disk for a Bun server, and a Worker hands over the JSON it bundles
+ * (`./d1.ts`). ONE rule for both — until task 2096 music's Worker carried its own copy of it.
+ *
+ * Anything it cannot read is `[]`, never a throw: see `places.ts`, "Missing is EMPTY".
+ */
+import type { PlaceRef } from "./policy.js";
+export declare function placesFromManifest(doc: unknown): PlaceRef[];

package/dist/server/engagement/manifestPlaces.js

@@ -0,0 +1,17 @@
+export function placesFromManifest(doc) {
+    const routes = Array.isArray(doc) ? doc : doc?.routes;
+    if (!Array.isArray(routes))
+        return [];
+    const seen = new Set();
+    const places = [];
+    for (const raw of routes) {
+        const r = raw;
+        if (!r || typeof r.id !== "string" || !r.id || seen.has(r.id))
+            continue;
+        seen.add(r.id);
+        places.push({ id: r.id, path: typeof r.path === "string" ? r.path : "" });
+    }
+    // Sorted so the allowlist a board renders is stable between deployments.
+    places.sort((a, b) => a.id.localeCompare(b.id));
+    return places;
+}

package/dist/server/engagement/places.js

@@ -24,6 +24,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { placesFromManifest } from "./manifestPlaces.js";
 /** Where the manifest sits, in a source tree and in a built artifact alike. */
 const MANIFEST = "routes.manifest.json";
 /**
@@ -38,24 +39,7 @@ export function engagementPlacesFor(dir) {
     if (!existsSync(path))
         return [];
     try {
-        const doc = JSON.parse(readFileSync(path, "utf8"));
-        const routes = Array.isArray(doc)
-            ? doc
-            : doc.routes;
-        if (!Array.isArray(routes))
-            return [];
-        const seen = new Set();
-        const places = [];
-        for (const raw of routes) {
-            const r = raw;
-            if (typeof r.id !== "string" || !r.id || seen.has(r.id))
-                continue;
-            seen.add(r.id);
-            places.push({ id: r.id, path: typeof r.path === "string" ? r.path : "" });
-        }
-        // Sorted so the allowlist a board renders is stable between deployments.
-        places.sort((a, b) => a.id.localeCompare(b.id));
-        return places;
+        return placesFromManifest(JSON.parse(readFileSync(path, "utf8")));
     }
     catch {
         return [];

package/dist/server/notifications/d1.d.ts

@@ -0,0 +1,80 @@
+/**
+ * `cursedbelt-server/notifications/d1` — the notification service over D1, for an app a Worker
+ * serves.
+ *
+ * ── Why it exists ───────────────────────────────────────────────────────────
+ * `createNotificationService` builds cwip's `createSqliteNotificationStore` over a synchronous
+ * `bun:sqlite` handle; a Worker has neither. `apps/family`'s port to a Worker + D1 (task 393)
+ * needs the SAME inbox — the same table, the same coalescing, the same routes — so this is
+ * cwip's `NotificationStore` contract implemented over D1, handed to cwip's own
+ * `createNotificationCenter`, and mounted by the same `mountNotificationRoutes`. The engine
+ * stays cwip's; only the storage changes.
+ *
+ * ── What is the same, and what is not ─────────────────────────────────────
+ *   · The table is `createSqliteNotificationStore`'s, column for column and index for index
+ *     ({@link notificationsDdl}; `./d1.spec.ts` compares the two schemas), so coalescing is
+ *     still the partial unique index and never only a read.
+ *   · Every store method runs cwip's statement, bound identically; `./d1.spec.ts` drives both
+ *     stores through one scenario and compares every result and every row.
+ *   · 🔴 `hub` is always `null` and `{base}/stream` is never mounted. Live delivery is an
+ *     in-memory set of open streams, and a Worker isolate cannot share one with the isolate
+ *     that produced the notification — a stream route that answered 200 and never emitted
+ *     would be worse than the 404 the client already falls back from. The poll transport is
+ *     the delivery story here, exactly as it is for `live: false` on the Mac.
+ *   · 🔴 No DDL runs here, ever. The sync store migrates on construction; on D1 the table is
+ *     the app's `db/schema.sql`, built from {@link notificationsDdl} (or from an in-memory run
+ *     of `NOTIFICATION_MIGRATIONS` — the two converge, and the spec proves it).
+ *
+ * 🔴 Worker-safe: nothing reachable from here at runtime imports `bun:*`
+ * (`../telemetryIsWorkerSafe.spec.ts` walks it). Do not import `./service.js`,
+ * `./migrations.js` or `./index.js` here.
+ *
+ * ```ts
+ * import { createD1NotificationService } from "cursedbelt-server/notifications/d1";
+ *
+ * const notifications = createD1NotificationService({ db: createRemoteD1(env.DB) });
+ * notifications.mount(app, { authorize: (c) => sso.userOf(c)?.id ?? null });
+ * await notifications.center.notify(userId, { type: "share.grant", title: "Shared with you" });
+ * ```
+ */
+import { type NotificationStore } from "cwip/notifications";
+import type { D1LikeDatabase } from "../d1/types.js";
+import type { NotificationService } from "./types.js";
+export type { NotificationService, NotificationServiceMountOptions } from "./types.js";
+/** The default table — the name `createSqliteNotificationStore` and `NOTIFICATION_MIGRATIONS` use. */
+export declare const D1_NOTIFICATIONS_TABLE = "notifications";
+/**
+ * The DDL a D1 schema needs for the notification table — the FINAL shape
+ * `createSqliteNotificationStore` migrates any database to (its later `source`/`severity`
+ * columns are in the CREATE, as they are in cwip's), with both indexes. Idempotent.
+ */
+export declare function notificationsDdl(table?: string): string[];
+/** {@link notificationsDdl} for the default table. */
+export declare const NOTIFICATIONS_DDL: readonly string[];
+export interface D1NotificationStoreOptions {
+    /** Table name override (identifier-validated). Default `notifications`. */
+    table?: string;
+}
+/**
+ * cwip's `NotificationStore` over D1 — the same statements as `createSqliteNotificationStore`,
+ * awaited. Every method is user-scoped, as the contract requires. Runs no DDL.
+ */
+export declare function createD1NotificationStore(db: D1LikeDatabase, options?: D1NotificationStoreOptions): NotificationStore;
+export interface CreateD1NotificationServiceOptions {
+    /** The app's D1 handle — `createRemoteD1(env.DB)` on a Worker, `createLocalD1(sqlite)` in a test. */
+    db: D1LikeDatabase;
+    /** Table name override (identifier-validated). */
+    table?: string;
+    /** Resolve a role audience (`notifyAudience({ role })`) to user ids. */
+    resolveRole?: (role: string) => Promise<string[]>;
+    /** Producer-path failures land here. Defaults to stderr. */
+    onError?: (error: unknown, context: string) => void;
+    /** Test seams, forwarded to the center. */
+    now?: () => number;
+    newId?: () => string;
+}
+/**
+ * The whole server half over D1 — `createNotificationService`'s shape, with `hub: null`.
+ * `mount` hangs the same routes on the app, minus `{base}/stream` (see the header).
+ */
+export declare function createD1NotificationService(options: CreateD1NotificationServiceOptions): NotificationService;