@holo-js/notifications 0.1.3

package/dist/index.mjs

@@ -0,0 +1,842 @@
+import {
+  createAnonymousNotificationTarget,
+  defineNotification,
+  isNotificationDefinition,
+  normalizeNotificationDefinition,
+  notificationsInternals
+} from "./chunk-INGM2JYY.mjs";
+
+// src/runtime.ts
+import { randomUUID } from "crypto";
+import { holoNotificationsDefaults } from "@holo-js/config";
+
+// src/registry.ts
+function normalizeChannelName(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error("[@holo-js/notifications] Notification channel names must be non-empty strings.");
+  }
+  return normalized;
+}
+function getRegistry() {
+  const runtime = globalThis;
+  runtime.__holoNotificationChannelRegistry__ ??= /* @__PURE__ */ new Map();
+  return runtime.__holoNotificationChannelRegistry__;
+}
+function registerNotificationChannel(name, channel, options = {}) {
+  const normalizedName = normalizeChannelName(name);
+  if (typeof channel?.send !== "function") {
+    throw new Error(`[@holo-js/notifications] Notification channel "${normalizedName}" must define send().`);
+  }
+  const registry = getRegistry();
+  if (registry.has(normalizedName) && options.replaceExisting !== true) {
+    throw new Error(`[@holo-js/notifications] Notification channel "${normalizedName}" is already registered.`);
+  }
+  registry.set(normalizedName, Object.freeze({
+    name: normalizedName,
+    channel
+  }));
+}
+function getRegisteredNotificationChannel(name) {
+  return getRegistry().get(normalizeChannelName(name));
+}
+function listRegisteredNotificationChannels() {
+  return Object.freeze([...getRegistry().values()]);
+}
+function resetNotificationChannelRegistry() {
+  getRegistry().clear();
+}
+var notificationRegistryInternals = {
+  getRegistry,
+  normalizeChannelName
+};
+
+// src/runtime.ts
+var HOLO_NOTIFICATIONS_DELIVER_JOB = "holo.notifications.deliver";
+function normalizeOptionalString(value, label) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`[@holo-js/notifications] ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function normalizeDelayValue(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`[@holo-js/notifications] ${label} must be a finite number greater than or equal to 0.`);
+    }
+    return value;
+  }
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw new Error(`[@holo-js/notifications] ${label} dates must be valid Date instances.`);
+  }
+  return value;
+}
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isAnonymousTarget(value) {
+  return isObject(value) && value.anonymous === true && isObject(value.routes);
+}
+function getRuntimeBindings() {
+  return getRuntimeState().bindings ?? {};
+}
+function getRuntimeState() {
+  const runtime = globalThis;
+  runtime.__holoNotificationsRuntime__ ??= {};
+  return runtime.__holoNotificationsRuntime__;
+}
+function getDispatchHandler() {
+  const bindings = getRuntimeBindings();
+  return bindings.dispatch ?? dispatchNotifications;
+}
+function dynamicImport(specifier) {
+  return import(specifier);
+}
+async function loadQueueModule() {
+  const override = getRuntimeState().loadQueueModule;
+  if (override) {
+    try {
+      return await override();
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+        throw new Error("[@holo-js/notifications] Queued or delayed notifications require @holo-js/queue to be installed.");
+      }
+      throw error;
+    }
+  }
+  try {
+    return await dynamicImport("@holo-js/queue");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error("[@holo-js/notifications] Queued or delayed notifications require @holo-js/queue to be installed.");
+    }
+    throw error;
+  }
+}
+async function loadDbModule() {
+  const override = getRuntimeState().loadDbModule;
+  if (override) {
+    try {
+      return await override();
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  try {
+    return await dynamicImport("@holo-js/db");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") {
+      return null;
+    }
+    throw error;
+  }
+}
+function createNotificationContext(anonymous) {
+  return Object.freeze({ anonymous });
+}
+function createBuildContext(channel, anonymous) {
+  return Object.freeze({
+    channel,
+    anonymous
+  });
+}
+function normalizeEmailRouteFromValue(value) {
+  if (typeof value === "string") {
+    const email = value.trim();
+    if (!email) {
+      throw new Error("[@holo-js/notifications] Email routes must be non-empty strings.");
+    }
+    return email;
+  }
+  if (!isObject(value) || typeof value.email !== "string" || !value.email.trim()) {
+    throw new Error("[@holo-js/notifications] Email routes must be a string or an object with a non-empty email.");
+  }
+  return Object.freeze({
+    email: value.email.trim(),
+    ...typeof value.name === "string" && value.name.trim() ? { name: value.name.trim() } : {}
+  });
+}
+function resolveEmailRouteFromNotifiable(notifiable) {
+  if (!isObject(notifiable) || typeof notifiable.email !== "string" || !notifiable.email.trim()) {
+    throw new Error("[@holo-js/notifications] Email notifications require a notifiable with a non-empty email.");
+  }
+  return Object.freeze({
+    email: notifiable.email.trim(),
+    ...typeof notifiable.name === "string" && notifiable.name.trim() ? { name: notifiable.name.trim() } : {}
+  });
+}
+function normalizeDatabaseRouteFromValue(value) {
+  if (!isObject(value) || typeof value.id !== "string" && typeof value.id !== "number" || typeof value.type !== "string" || !value.type.trim()) {
+    throw new Error("[@holo-js/notifications] Database routes must include a string or numeric id and a non-empty type.");
+  }
+  return Object.freeze({
+    id: value.id,
+    type: value.type.trim()
+  });
+}
+function resolveDatabaseRouteFromNotifiable(notifiable) {
+  if (!isObject(notifiable) || typeof notifiable.id !== "string" && typeof notifiable.id !== "number") {
+    throw new Error("[@holo-js/notifications] Database notifications require a notifiable with a string or numeric id.");
+  }
+  const explicitType = typeof notifiable.type === "string" && notifiable.type.trim() ? notifiable.type.trim() : void 0;
+  if (explicitType) {
+    return Object.freeze({
+      id: notifiable.id,
+      type: explicitType
+    });
+  }
+  const constructorName = isObject(notifiable) && "constructor" in notifiable && typeof notifiable.constructor === "function" && typeof notifiable.constructor.name === "string" ? notifiable.constructor.name.trim() : "";
+  if (!constructorName || constructorName === "Object") {
+    throw new Error(
+      "[@holo-js/notifications] Database notifications require a notifiable.type or a non-plain-object constructor name."
+    );
+  }
+  return Object.freeze({
+    id: notifiable.id,
+    type: constructorName
+  });
+}
+function normalizeBroadcastRouteFromValue(value) {
+  if (typeof value === "string") {
+    const channel = value.trim();
+    if (!channel) {
+      throw new Error("[@holo-js/notifications] Broadcast routes must be non-empty strings.");
+    }
+    return channel;
+  }
+  if (Array.isArray(value)) {
+    const channels = value.map((entry, index) => {
+      if (typeof entry !== "string" || !entry.trim()) {
+        throw new Error(`[@holo-js/notifications] Broadcast route entry at index ${index} must be a non-empty string.`);
+      }
+      return entry.trim();
+    });
+    if (channels.length === 0) {
+      throw new Error("[@holo-js/notifications] Broadcast routes must include at least one channel.");
+    }
+    return Object.freeze(channels);
+  }
+  if (!isObject(value) || !Array.isArray(value.channels)) {
+    throw new Error("[@holo-js/notifications] Broadcast routes must be a string, string array, or object with channels.");
+  }
+  return Object.freeze({
+    channels: normalizeBroadcastRouteFromValue(value.channels)
+  });
+}
+function resolveBroadcastRouteFromNotifiable(notifiable) {
+  if (!isObject(notifiable)) {
+    throw new Error(
+      "[@holo-js/notifications] Broadcast notifications require an anonymous route or a routeNotificationForBroadcast() method."
+    );
+  }
+  if (typeof notifiable.routeNotificationForBroadcast === "function") {
+    return normalizeBroadcastRouteFromValue(notifiable.routeNotificationForBroadcast());
+  }
+  if (typeof notifiable.broadcastChannels === "function") {
+    return normalizeBroadcastRouteFromValue(notifiable.broadcastChannels());
+  }
+  if ("broadcastChannels" in notifiable) {
+    return normalizeBroadcastRouteFromValue(notifiable.broadcastChannels);
+  }
+  throw new Error(
+    "[@holo-js/notifications] Broadcast notifications require an anonymous route or a routeNotificationForBroadcast() method."
+  );
+}
+function normalizeNotificationRecord(route, payload, notificationType) {
+  const now = /* @__PURE__ */ new Date();
+  return Object.freeze({
+    id: randomUUID(),
+    type: notificationType,
+    notifiableType: route.type,
+    notifiableId: route.id,
+    data: payload.data,
+    readAt: null,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+function requireMailer(bindings) {
+  if (!bindings.mailer) {
+    throw new Error("[@holo-js/notifications] Email notifications require a configured mailer runtime.");
+  }
+  return bindings.mailer;
+}
+function requireBroadcaster(bindings) {
+  if (!bindings.broadcaster) {
+    throw new Error("[@holo-js/notifications] Broadcast notifications require a configured broadcaster runtime.");
+  }
+  return bindings.broadcaster;
+}
+function requireStore(bindings) {
+  if (!bindings.store) {
+    throw new Error("[@holo-js/notifications] Database notifications require a configured notification store runtime.");
+  }
+  return bindings.store;
+}
+function normalizeNotificationRecordIds(ids) {
+  const normalized = ids.map((value, index) => {
+    if (typeof value !== "string" || !value.trim()) {
+      throw new Error(`[@holo-js/notifications] Notification id at index ${index} must be a non-empty string.`);
+    }
+    return value.trim();
+  });
+  return Object.freeze([...new Set(normalized)]);
+}
+var builtInChannels = Object.freeze({
+  email: Object.freeze({
+    resolveRoute: resolveEmailRouteFromNotifiable,
+    async send(input) {
+      await requireMailer(getRuntimeBindings()).send(
+        input.payload,
+        input
+      );
+    }
+  }),
+  database: Object.freeze({
+    resolveRoute: resolveDatabaseRouteFromNotifiable,
+    async send(input) {
+      const route = input.route;
+      if (!route) {
+        throw new Error("[@holo-js/notifications] Database notifications require a resolved route.");
+      }
+      await requireStore(getRuntimeBindings()).create(
+        normalizeNotificationRecord(
+          route,
+          input.payload,
+          input.notificationType
+        )
+      );
+    }
+  }),
+  broadcast: Object.freeze({
+    resolveRoute: resolveBroadcastRouteFromNotifiable,
+    async send(input) {
+      await requireBroadcaster(getRuntimeBindings()).send(
+        input.payload,
+        input
+      );
+    }
+  })
+});
+function getNotificationChannel(name) {
+  if (name in builtInChannels) {
+    return builtInChannels[name];
+  }
+  return getRegisteredNotificationChannel(name)?.channel;
+}
+function resolveTargets(target) {
+  if (target.kind === "anonymous") {
+    const anonymous = target.value;
+    if (!isAnonymousTarget(anonymous)) {
+      throw new Error("[@holo-js/notifications] Anonymous notification targets must be created through notifyUsing().");
+    }
+    return Object.freeze([Object.freeze({
+      index: 0,
+      anonymous: true,
+      notifiable: anonymous,
+      routes: anonymous.routes
+    })]);
+  }
+  if (target.kind === "many") {
+    if (!Array.isArray(target.value)) {
+      throw new Error("[@holo-js/notifications] Multi-target notification dispatch requires an array target.");
+    }
+    return Object.freeze(target.value.map((notifiable, index) => Object.freeze({
+      index,
+      anonymous: false,
+      notifiable
+    })));
+  }
+  return Object.freeze([Object.freeze({
+    index: 0,
+    anonymous: false,
+    notifiable: target.value
+  })]);
+}
+function resolveChannels(notification, target) {
+  const channels = notification.via(target.notifiable, createNotificationContext(target.anonymous));
+  if (!Array.isArray(channels)) {
+    throw new Error("[@holo-js/notifications] Notification via() must return an array of channel names.");
+  }
+  return Object.freeze(channels.map((channel, index) => {
+    if (typeof channel !== "string") {
+      throw new Error(`[@holo-js/notifications] Notification channel at index ${index} must be a string.`);
+    }
+    const normalized = normalizeOptionalString(channel, "Notification channel");
+    if (!getNotificationChannel(normalized)) {
+      throw new Error(`[@holo-js/notifications] Notification channel "${normalized}" is not registered.`);
+    }
+    return normalized;
+  }));
+}
+function resolvePayload(notification, channel, target) {
+  const factory = notification.build[channel];
+  if (typeof factory !== "function") {
+    throw new Error(
+      `[@holo-js/notifications] Notification channel "${channel}" is listed in via() but has no build.${channel}() payload factory.`
+    );
+  }
+  return factory(target.notifiable, createBuildContext(channel, target.anonymous));
+}
+function resolveNotificationQueueOptions(notification, target, channel) {
+  if (typeof notification.queue === "function") {
+    return notification.queue(
+      target.notifiable,
+      channel,
+      createNotificationContext(target.anonymous)
+    );
+  }
+  return notification.queue ?? false;
+}
+function resolveNotificationDelay(notification, target, channel) {
+  if (typeof notification.delay === "function") {
+    return notification.delay(
+      target.notifiable,
+      channel,
+      createNotificationContext(target.anonymous)
+    );
+  }
+  if (typeof notification.delay === "undefined") {
+    return void 0;
+  }
+  if (typeof notification.delay === "number" || notification.delay instanceof Date) {
+    return notification.delay;
+  }
+  return notification.delay[channel];
+}
+function resolveRoute(channel, target) {
+  if (target.anonymous) {
+    if (!(channel in (target.routes ?? {}))) {
+      throw new Error(`[@holo-js/notifications] Anonymous notifications must define a route for channel "${channel}".`);
+    }
+    const route = target.routes?.[channel];
+    if (channel === "email") {
+      return normalizeEmailRouteFromValue(route);
+    }
+    if (channel === "database") {
+      return normalizeDatabaseRouteFromValue(route);
+    }
+    if (channel === "broadcast") {
+      return normalizeBroadcastRouteFromValue(route);
+    }
+    return route;
+  }
+  const registered = getNotificationChannel(channel);
+  if (!registered) {
+    throw new Error(`[@holo-js/notifications] Notification channel "${channel}" is not registered.`);
+  }
+  if ("resolveRoute" in registered && typeof registered.resolveRoute === "function") {
+    return registered.resolveRoute(target.notifiable);
+  }
+  if (isObject(registered) && typeof registered.validateRoute === "function") {
+    const routedNotifiable = isObject(target.notifiable) && typeof target.notifiable.routeNotificationFor === "function" ? target.notifiable.routeNotificationFor(channel) : void 0;
+    if (typeof routedNotifiable === "undefined") {
+      return void 0;
+    }
+    return registered.validateRoute(routedNotifiable);
+  }
+  if (isObject(target.notifiable) && typeof target.notifiable.routeNotificationFor === "function") {
+    return target.notifiable.routeNotificationFor(channel);
+  }
+  return void 0;
+}
+function resolveChannelSendContext(notification, channel, target) {
+  const payload = resolvePayload(notification, channel, target);
+  return Object.freeze({
+    channel,
+    anonymous: target.anonymous,
+    notifiable: target.notifiable,
+    route: resolveRoute(channel, target),
+    notificationType: notification.type,
+    payload,
+    targetIndex: target.index
+  });
+}
+function resolveChannelDispatchPlan(notification, target, channel, options) {
+  const notificationQueue = resolveNotificationQueueOptions(notification, target, channel);
+  const notificationQueueOptions = notificationQueue && notificationQueue !== true ? notificationQueue : void 0;
+  const config = getRuntimeBindings().config ?? holoNotificationsDefaults;
+  const resolvedDelay = options.delayByChannel?.[channel] ?? options.delay ?? resolveNotificationDelay(notification, target, channel);
+  const resolvedConnection = options.connection ?? notificationQueueOptions?.connection ?? config.queue.connection;
+  const resolvedQueue = options.queue ?? notificationQueueOptions?.queue ?? config.queue.queue;
+  const afterCommit = options.afterCommit ?? notificationQueueOptions?.afterCommit ?? config.queue.afterCommit;
+  const queued = notificationQueue === true || !!notificationQueueOptions || typeof resolvedDelay !== "undefined" || typeof resolvedConnection !== "undefined" || typeof resolvedQueue !== "undefined";
+  return Object.freeze({
+    channel,
+    queued,
+    connection: queued ? resolvedConnection : void 0,
+    queue: queued ? resolvedQueue : void 0,
+    delay: queued ? resolvedDelay : void 0,
+    afterCommit
+  });
+}
+async function deliverResolvedNotificationChannel(context) {
+  const definition = getNotificationChannel(context.channel);
+  if (!definition) {
+    throw new Error(`[@holo-js/notifications] Notification channel "${context.channel}" is not registered.`);
+  }
+  const routeValidated = isObject(definition) && typeof definition.validateRoute === "function" && typeof context.route !== "undefined" ? definition.validateRoute(context.route) : context.route;
+  const runtimeContext = typeof routeValidated === "undefined" ? context : Object.freeze({
+    ...context,
+    route: routeValidated
+  });
+  return await definition.send(runtimeContext);
+}
+function createQueuedDeliveryPayload(context) {
+  return Object.freeze({
+    channel: context.channel,
+    anonymous: context.anonymous,
+    notifiable: context.notifiable,
+    ...typeof context.route === "undefined" ? {} : { route: context.route },
+    ...typeof context.notificationType === "undefined" ? {} : { notificationType: context.notificationType },
+    payload: context.payload,
+    targetIndex: context.targetIndex
+  });
+}
+async function runQueuedNotificationDelivery(payload) {
+  return await deliverResolvedNotificationChannel(Object.freeze({
+    channel: payload.channel,
+    anonymous: payload.anonymous,
+    notifiable: payload.notifiable,
+    route: payload.route,
+    notificationType: payload.notificationType,
+    payload: payload.payload,
+    targetIndex: payload.targetIndex
+  }));
+}
+async function ensureNotificationsQueueJobRegistered(queueModule) {
+  const resolvedQueueModule = queueModule ?? await loadQueueModule();
+  if (resolvedQueueModule.getRegisteredQueueJob(HOLO_NOTIFICATIONS_DELIVER_JOB)) {
+    return resolvedQueueModule;
+  }
+  resolvedQueueModule.registerQueueJob(
+    resolvedQueueModule.defineJob({
+      async handle(payload) {
+        return await runQueuedNotificationDelivery(payload);
+      }
+    }),
+    { name: HOLO_NOTIFICATIONS_DELIVER_JOB }
+  );
+  return resolvedQueueModule;
+}
+async function dispatchQueuedNotificationChannel(context, plan) {
+  const queueModule = await ensureNotificationsQueueJobRegistered();
+  let pending = queueModule.dispatch(
+    HOLO_NOTIFICATIONS_DELIVER_JOB,
+    createQueuedDeliveryPayload(context)
+  );
+  if (typeof plan.connection !== "undefined") {
+    pending = pending.onConnection(plan.connection);
+  }
+  if (typeof plan.queue !== "undefined") {
+    pending = pending.onQueue(plan.queue);
+  }
+  if (typeof plan.delay !== "undefined") {
+    pending = pending.delay(plan.delay);
+  }
+  await pending.dispatch();
+}
+async function deferDispatchUntilCommit(input, targets, notification) {
+  const dbModule = await loadDbModule();
+  const active = dbModule?.connectionAsyncContext.getActive()?.connection;
+  if (!active || active.getScope().kind === "root") {
+    return null;
+  }
+  const channels = [];
+  for (const target of targets) {
+    for (const channel of resolveChannels(notification, target)) {
+      const plan = resolveChannelDispatchPlan(notification, target, channel, input.options);
+      channels.push(Object.freeze({
+        channel,
+        targetIndex: target.index,
+        queued: plan.queued,
+        deferred: true,
+        success: true
+      }));
+    }
+  }
+  active.afterCommit(async () => {
+    await dispatchNotifications(input, { allowAfterCommitDeferral: false });
+  });
+  return Object.freeze({
+    totalTargets: targets.length,
+    channels: Object.freeze(channels),
+    deferred: true
+  });
+}
+function shouldDeferDispatchAfterCommit(notification, targets, options) {
+  if (options.afterCommit) {
+    return true;
+  }
+  return targets.some((target) => resolveChannels(notification, target).some((channel) => {
+    return resolveChannelDispatchPlan(notification, target, channel, options).afterCommit;
+  }));
+}
+async function dispatchNotifications(input, execution = {}) {
+  const notification = normalizeNotificationDefinition(input.notification);
+  const targets = resolveTargets(input.target);
+  if (execution.allowAfterCommitDeferral !== false && shouldDeferDispatchAfterCommit(notification, targets, input.options)) {
+    const deferredResult = await deferDispatchUntilCommit(input, targets, notification);
+    if (deferredResult) {
+      return deferredResult;
+    }
+  }
+  const results = [];
+  for (const target of targets) {
+    const channels = resolveChannels(notification, target);
+    for (const channel of channels) {
+      try {
+        const context = resolveChannelSendContext(notification, channel, target);
+        const plan = resolveChannelDispatchPlan(notification, target, channel, input.options);
+        const result = plan.queued ? await dispatchQueuedNotificationChannel(context, plan) : await deliverResolvedNotificationChannel(context);
+        results.push(Object.freeze({
+          channel,
+          targetIndex: target.index,
+          queued: plan.queued,
+          success: true,
+          ...typeof result === "undefined" ? {} : { result }
+        }));
+      } catch (error) {
+        results.push(Object.freeze({
+          channel,
+          targetIndex: target.index,
+          queued: false,
+          success: false,
+          error
+        }));
+      }
+    }
+  }
+  return Object.freeze({
+    totalTargets: targets.length,
+    channels: Object.freeze(results)
+  });
+}
+var PendingDispatch = class {
+  constructor(target, notification, options = {}) {
+    this.target = target;
+    this.notification = notification;
+    this.options = options;
+  }
+  #promise;
+  onConnection(name) {
+    this.options.connection = normalizeOptionalString(name, "Notification queue connection");
+    return this;
+  }
+  onQueue(name) {
+    this.options.queue = normalizeOptionalString(name, "Notification queue name");
+    return this;
+  }
+  delay(value) {
+    this.options.delay = normalizeDelayValue(value, "Notification delay");
+    return this;
+  }
+  delayFor(channel, value) {
+    const normalizedChannel = normalizeOptionalString(channel, "Notification channel");
+    this.options.delayByChannel ??= {};
+    this.options.delayByChannel[normalizedChannel] = normalizeDelayValue(value, `Notification delay for channel "${normalizedChannel}"`);
+    return this;
+  }
+  afterCommit() {
+    this.options.afterCommit = true;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#execute().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#execute().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#execute().finally(onfinally ?? void 0);
+  }
+  #execute() {
+    if (!this.#promise) {
+      try {
+        this.#promise = getDispatchHandler()({
+          target: typeof this.target === "function" ? this.target() : this.target,
+          notification: this.notification,
+          options: Object.freeze({
+            connection: this.options.connection,
+            queue: this.options.queue,
+            delay: this.options.delay,
+            delayByChannel: this.options.delayByChannel ? Object.freeze({ ...this.options.delayByChannel }) : void 0,
+            afterCommit: this.options.afterCommit
+          })
+        });
+      } catch (error) {
+        this.#promise = Promise.reject(error);
+      }
+    }
+    return this.#promise;
+  }
+};
+var AnonymousNotificationBuilder = class _AnonymousNotificationBuilder {
+  target;
+  constructor(routes = {}) {
+    this.target = createAnonymousNotificationTarget(routes);
+  }
+  channel(channel, route) {
+    const normalizedChannel = normalizeOptionalString(channel, "Notification channel");
+    return new _AnonymousNotificationBuilder({
+      ...this.target.routes,
+      [normalizedChannel]: route
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- must accept any NotificationDefinition variant
+  notify(notification) {
+    return new PendingDispatch({
+      kind: "anonymous",
+      value: this.target
+    }, notification);
+  }
+};
+function configureNotificationsRuntime(bindings) {
+  getRuntimeState().bindings = bindings;
+}
+function getNotificationsRuntimeBindings() {
+  return getRuntimeBindings();
+}
+function resetNotificationsRuntime() {
+  const state = getRuntimeState();
+  state.bindings = void 0;
+  state.loadQueueModule = void 0;
+  state.loadDbModule = void 0;
+}
+function notify(notifiable, notification) {
+  return new PendingDispatch({
+    kind: "notifiable",
+    value: notifiable
+  }, notification);
+}
+function notifyMany(notifiables, notification) {
+  return new PendingDispatch(() => ({
+    kind: "many",
+    value: Object.freeze([...notifiables])
+  }), notification);
+}
+function notifyUsing() {
+  return new AnonymousNotificationBuilder();
+}
+async function listNotifications(notifiable) {
+  return requireStore(getRuntimeBindings()).list(resolveDatabaseRouteFromNotifiable(notifiable));
+}
+async function unreadNotifications(notifiable) {
+  return requireStore(getRuntimeBindings()).unread(resolveDatabaseRouteFromNotifiable(notifiable));
+}
+async function markNotificationsAsRead(ids) {
+  return requireStore(getRuntimeBindings()).markAsRead(normalizeNotificationRecordIds(ids));
+}
+async function markNotificationsAsUnread(ids) {
+  return requireStore(getRuntimeBindings()).markAsUnread(normalizeNotificationRecordIds(ids));
+}
+async function deleteNotifications(ids) {
+  return requireStore(getRuntimeBindings()).delete(normalizeNotificationRecordIds(ids));
+}
+function getNotificationsRuntime() {
+  return Object.freeze({
+    notify,
+    notifyMany,
+    notifyUsing,
+    listNotifications,
+    unreadNotifications,
+    markNotificationsAsRead,
+    markNotificationsAsUnread,
+    deleteNotifications
+  });
+}
+var notificationsRuntimeInternals = {
+  HOLO_NOTIFICATIONS_DELIVER_JOB,
+  AnonymousNotificationBuilder,
+  PendingDispatch,
+  builtInChannels,
+  createBuildContext,
+  createNotificationContext,
+  createQueuedDeliveryPayload,
+  deferDispatchUntilCommit,
+  deliverResolvedNotificationChannel,
+  dispatchNotifications,
+  dispatchQueuedNotificationChannel,
+  ensureNotificationsQueueJobRegistered,
+  getDispatchHandler,
+  getRuntimeBindings,
+  getRuntimeState,
+  getNotificationChannel,
+  isAnonymousTarget,
+  isObject,
+  loadDbModule,
+  loadQueueModule,
+  normalizeBroadcastRouteFromValue,
+  normalizeDatabaseRouteFromValue,
+  normalizeDelayValue,
+  normalizeEmailRouteFromValue,
+  normalizeNotificationRecord,
+  normalizeNotificationRecordIds,
+  normalizeOptionalString,
+  resolveBroadcastRouteFromNotifiable,
+  resolveChannelDispatchPlan,
+  resolveChannels,
+  resolveDatabaseRouteFromNotifiable,
+  resolveEmailRouteFromNotifiable,
+  resolveNotificationDelay,
+  resolveNotificationQueueOptions,
+  resolvePayload,
+  resolveRoute,
+  runQueuedNotificationDelivery,
+  resolveTargets,
+  setDbModuleLoader(loader) {
+    getRuntimeState().loadDbModule = loader;
+  },
+  setQueueModuleLoader(loader) {
+    getRuntimeState().loadQueueModule = loader;
+  }
+};
+
+// src/index.ts
+import {
+  defineNotificationsConfig as defineBaseNotificationsConfig
+} from "@holo-js/config";
+function defineNotificationsConfig(config) {
+  return defineBaseNotificationsConfig(config);
+}
+var notifications = Object.freeze({
+  deleteNotifications,
+  listNotifications,
+  markNotificationsAsRead,
+  markNotificationsAsUnread,
+  notify,
+  notifyMany,
+  notifyUsing,
+  unreadNotifications
+});
+var src_default = notifications;
+export {
+  configureNotificationsRuntime,
+  src_default as default,
+  defineNotification,
+  defineNotificationsConfig,
+  deleteNotifications,
+  getNotificationsRuntime,
+  getNotificationsRuntimeBindings,
+  getRegisteredNotificationChannel,
+  isNotificationDefinition,
+  listNotifications,
+  listRegisteredNotificationChannels,
+  markNotificationsAsRead,
+  markNotificationsAsUnread,
+  normalizeNotificationDefinition,
+  notificationRegistryInternals,
+  notificationsInternals,
+  notificationsRuntimeInternals,
+  notify,
+  notifyMany,
+  notifyUsing,
+  registerNotificationChannel,
+  resetNotificationChannelRegistry,
+  resetNotificationsRuntime,
+  unreadNotifications
+};