@visulima/notification 0.0.1 → 1.0.0-alpha.2

package/dist/template-engines/liquid.d.ts

@@ -0,0 +1,16 @@
+import { T as TemplateRenderer } from "../packem_shared/types.d-td-F2Oh0.js";
+/**
+* Renders a [LiquidJS](https://liquidjs.com/) template to a string.
+*
+* `liquidjs` is an optional peer, loaded lazily so a missing install surfaces here as
+* a {@link NotificationError} rather than at import time. Pure JS — edge-safe and
+* runnable on Cloudflare Workers.
+* @param template The Liquid template string.
+* @param data The data/variables exposed to the template.
+* @param options LiquidJS engine options (passed to the `Liquid` constructor).
+* @returns The rendered output.
+* @throws {TypeError} When the template is not a string.
+* @throws {NotificationError} When `liquidjs` is not installed or rendering fails.
+*/
+declare const renderLiquid: TemplateRenderer;
+export { renderLiquid as default, renderLiquid };

package/dist/template-engines/liquid.js

@@ -0,0 +1 @@
+import r from"../packem_shared/NotificationError-DVfMJQ1u.js";const s=async(t,a,d)=>{if(typeof t!="string")throw new TypeError("Liquid template must be a string");let i;try{i=await import("liquidjs")}catch(e){throw new r("liquid","liquidjs is not installed. Please install it: pnpm add liquidjs",{cause:e})}try{return await new i.Liquid(d??{}).parseAndRender(t,a??{})}catch(e){throw new r("liquid",`Failed to render Liquid template: ${e.message}`,{cause:e})}};export{s as default,s as renderLiquid};

package/dist/template-engines/string.d.ts

@@ -0,0 +1,20 @@
+import { T as TemplateRenderer } from "../packem_shared/types.d-td-F2Oh0.js";
+/**
+* Zero-dependency `{{var}}` interpolation renderer. Edge-safe and peer-free.
+*
+* Replaces `{{ key }}` / `{{ a.b.c }}` placeholders with the matching value from
+* `data`. Unmatched placeholders render as an empty string. Whitespace inside the
+* braces is ignored. This is intentionally minimal — for conditionals/loops use the
+* Handlebars or Liquid renderers.
+* @param template The template string containing `{{var}}` placeholders.
+* @param data The data/variables to interpolate.
+* @returns The rendered string.
+* @throws {TypeError} When the template is not a string.
+* @example
+* ```ts
+* renderString("Hi {{ user.name }}, code {{code}}", { code: "123", user: { name: "Ada" } });
+* // => "Hi Ada, code 123"
+* ```
+*/
+declare const renderString: TemplateRenderer;
+export { renderString as default, renderString };

package/dist/template-engines/string.js

@@ -0,0 +1 @@
+const i=(n,r)=>{const o=r.split(".");let e=n;for(const s of o){if(e===null||typeof e!="object")return;e=e[s]}return e},f=(n,r)=>{if(typeof n!="string")throw new TypeError("String template must be a string");const o=r??{};return n.replaceAll(/\{\{\s*([\w.]+)\s*\}\}/g,(e,s)=>{const t=i(o,s);return t==null?"":typeof t=="string"?t:typeof t=="number"||typeof t=="boolean"||typeof t=="bigint"?String(t):JSON.stringify(t)})};export{f as default,f as renderString};

package/dist/utils/result.d.ts

@@ -0,0 +1,54 @@
+import { R as Result } from "../packem_shared/types.d-GUzX1jTk.js";
+/**
+* A successful {@link Result} with its data narrowed to be present.
+*/
+type OkResult<T> = Result<T> & {
+  data: T;
+  success: true;
+};
+/**
+* A failed {@link Result}, narrowed to the failure case.
+*/
+type FailResult<T> = Result<T> & {
+  success: false;
+};
+/**
+* Returns whether a {@link Result} succeeded, narrowing `data` to be present.
+* @param result The result to test.
+* @returns `true` when the result is successful.
+*/
+declare const isOk: <T>(result: Result<T>) => result is OkResult<T>;
+/**
+* Returns whether a {@link Result} failed.
+* @param result The result to test.
+* @returns `true` when the result is a failure.
+*/
+declare const isErr: <T>(result: Result<T>) => result is FailResult<T>;
+/**
+* Returns the data of a successful {@link Result}, or throws its error.
+* @param result The result to unwrap.
+* @returns The contained data.
+* @throws {NotificationError} The result's error (wrapped when it is not already an `Error`).
+*/
+declare const unwrap: <T>(result: Result<T>) => T;
+/**
+* Returns the data of a successful {@link Result}, or a fallback when it failed.
+* @param result The result to unwrap.
+* @param fallback The value to return on failure.
+* @returns The data, or the fallback.
+*/
+declare const unwrapOr: <T>(result: Result<T>, fallback: T) => T;
+/**
+* Maps the data of a successful {@link Result}, passing failures through unchanged.
+* @param result The result to map.
+* @param function_ The mapper applied to the data on success.
+* @returns A new result with the mapped data, or the original failure.
+*/
+declare const mapOk: <T, U>(result: Result<T>, function_: (data: T) => U) => Result<U>;
+/**
+* Runs an async function and captures its outcome as a {@link Result}, never throwing.
+* @param function_ The async function to run.
+* @returns A successful result with the value, or a failed result with the thrown error.
+*/
+declare const tryAsync: <T>(function_: () => Promise<T>) => Promise<Result<T>>;
+export { FailResult, OkResult, isErr, isOk, mapOk, tryAsync, unwrap, unwrapOr };

package/dist/utils/result.js

@@ -0,0 +1 @@
+import e from"../packem_shared/NotificationError-DVfMJQ1u.js";const c=r=>r.success,t=r=>!r.success,u=r=>{if(r.success)return r.data;throw r.error instanceof Error?r.error:new e("result","Called unwrap() on a failed result",{cause:r.error})},o=(r,s)=>r.success?r.data:s,n=(r,s)=>r.success?{data:s(r.data),success:!0}:{error:r.error,success:!1},d=async r=>{try{return{data:await r(),success:!0}}catch(s){return{error:s,success:!1}}};export{t as isErr,c as isOk,n as mapOk,d as tryAsync,u as unwrap,o as unwrapOr};

package/dist/webhooks/index.d.ts

@@ -0,0 +1,110 @@
+import { N as NotificationEvent } from "../packem_shared/types.d-GUzX1jTk.js";
+/**
+* Computes an HMAC over `message` and returns the lowercase hex digest.
+* @param key The shared secret (UTF-8 string) or raw key bytes.
+* @param message The message to sign.
+* @param hash The hash algorithm (`"SHA-1"` or `"SHA-256"`).
+* @returns The hex-encoded HMAC.
+*/
+declare const hmacHex: (key: string | Uint8Array, message: string, hash: "SHA-1" | "SHA-256") => Promise<string>;
+/**
+* Computes an HMAC over `message` and returns the base64 digest.
+* @param key The shared secret (UTF-8 string) or raw key bytes.
+* @param message The message to sign.
+* @param hash The hash algorithm (`"SHA-1"` or `"SHA-256"`).
+* @returns The base64-encoded HMAC.
+*/
+declare const hmacBase64: (key: string | Uint8Array, message: string, hash: "SHA-1" | "SHA-256") => Promise<string>;
+/**
+* Constant-time string comparison to avoid leaking match position via timing.
+*
+* Both inputs are compared in full; the function returns early only on length
+* mismatch (which is not secret).
+* @param a The first string.
+* @param b The second string.
+* @returns `true` when the strings are equal.
+*/
+declare const timingSafeEqual: (a: string, b: string) => boolean;
+/**
+* Case-insensitive map of inbound request headers. Values may be a single string or
+* an array (mirroring `node:http` and `Headers`); verifiers normalise both forms.
+*/
+type WebhookHeaders = Record<string, string | string[] | undefined>;
+/**
+* A provider inbound-webhook verifier: validates the request signature and normalises
+* the body into a {@link NotificationEvent}.
+*/
+interface WebhookVerifier {
+  /**
+  * Normalises a verified webhook body into a {@link NotificationEvent}.
+  * @param body The raw request body (string).
+  * @returns The normalised event, or `undefined` when the body is not a delivery event.
+  */
+  parse: (body: string) => NotificationEvent | undefined;
+  /**
+  * Verifies the request signature against the shared secret.
+  * @param payload The raw request body (string).
+  * @param headers The inbound request headers.
+  * @param secret The provider signing secret / auth token.
+  * @returns `true` when the signature is valid.
+  */
+  verify: (payload: string, headers: WebhookHeaders, secret: string) => Promise<boolean>;
+}
+/**
+* Reads a header value case-insensitively, coercing array values to their first entry.
+* @param headers The inbound headers.
+* @param name The header name to read.
+* @returns The header value, or `undefined` when absent.
+*/
+declare const getHeader: (headers: WebhookHeaders, name: string) => string | undefined;
+/**
+* Verifier + parser for Slack event/interaction webhooks.
+*
+* Verification follows Slack's v0 signing scheme: the signature is
+* `v0=` + hex HMAC-SHA256 (keyed by the signing secret) of `v0:{timestamp}:{body}`.
+* The request timestamp is checked against a 5-minute replay window. Edge-safe — uses
+* Web Crypto only.
+*/
+declare const slackWebhook: WebhookVerifier;
+/**
+* Verifier + parser for AWS SNS HTTP/S subscription deliveries.
+*
+* NOTE: signature verification is NOT yet implemented. Real verification requires
+* fetching the X.509 certificate at `SigningCertURL`, validating its cert chain back to
+* an Amazon root, and checking the RSA-SHA1/RSA-SHA256 signature over the canonical
+* string-to-sign (SignatureVersion 1 and 2). Until that lands, {@link snsWebhook.verify}
+* fails closed and always returns `false` — accepting a payload purely on its structure
+* (a `Signature` field plus an `sns.*.amazonaws.com` `SigningCertURL`) is an auth bypass,
+* since both are attacker-controllable. `parse` remains available for callers that have
+* verified the message out-of-band. Callers handling `SubscriptionConfirmation` should
+* confirm the subscription by requesting the `SubscribeURL` from the parsed metadata.
+* Edge-safe — performs no `node:*` work.
+*
+* TODO: implement RSA-SHA1/RSA-SHA256 verification of the canonical string-to-sign
+* against the fetched signing certificate (SignatureVersion 1 and 2).
+*/
+declare const snsWebhook: WebhookVerifier;
+/**
+* Verifier + parser implementing the generic
+* [Standard Webhooks](https://www.standardwebhooks.com/) HMAC scheme.
+*
+* The signed content is `{id}.{timestamp}.{body}`; the signature is the base64
+* HMAC-SHA256 prefixed with `v1,`. The `webhook-signature` header may carry several
+* space-separated signatures (key rotation) — verification passes when any matches.
+* If the secret begins with `whsec_`, the base64 remainder is decoded to raw key bytes
+* and the HMAC is keyed with those bytes (per the spec); otherwise the raw secret string
+* is used directly. A hex digest is also accepted as a fallback for non-conformant
+* senders. Edge-safe — uses Web Crypto only.
+*/
+declare const standardWebhook: WebhookVerifier;
+/**
+* Verifier + parser for Twilio status-callback webhooks.
+*
+* Verification follows Twilio's scheme: `X-Twilio-Signature` is the base64 HMAC-SHA1
+* (keyed by the auth token) of the request URL concatenated with the form parameters
+* sorted by key. The full request URL must be provided via the
+* `x-twilio-signature-url` header (the verifier cannot reconstruct it from the body).
+* Edge-safe — uses Web Crypto only.
+*/
+declare const twilioWebhook: WebhookVerifier;
+export { type WebhookHeaders, type WebhookVerifier, getHeader, hmacBase64, hmacHex, slackWebhook, snsWebhook, standardWebhook, timingSafeEqual, twilioWebhook };

package/dist/webhooks/index.js

@@ -0,0 +1 @@
+import{hmacBase64 as a,hmacHex as r,timingSafeEqual as t}from"../packem_shared/hmacBase64-BhhoX0uo.js";import{default as m}from"../packem_shared/slackWebhook-GEx_GdcV.js";import{default as d}from"../packem_shared/snsWebhook-ChZnBBT3.js";import{default as x}from"../packem_shared/standardWebhook-B-LxP8U7.js";import{default as p}from"../packem_shared/twilioWebhook-F0mTmGXD.js";import{getHeader as u}from"../packem_shared/getHeader-C_gkdnMQ.js";export{u as getHeader,a as hmacBase64,r as hmacHex,m as slackWebhook,d as snsWebhook,x as standardWebhook,t as timingSafeEqual,p as twilioWebhook};

package/dist/workflow/index.d.ts

@@ -0,0 +1,83 @@
+import { M as MaybePromise, D as Duration, W as WorkflowConfig, a as WorkflowDefinition } from "../packem_shared/types.d-C1GoEAlI.d-Bv3grfyD.js";
+import '@standard-schema/spec';
+import { C as ChannelPayloadMap, N as Notification } from "../packem_shared/notification.d-DFCVTods.js";
+import { C as ChannelType, c as Receipt } from "../packem_shared/types.d-GUzX1jTk.js";
+import "../packem_shared/types.d-CximoA8M.js";
+import "../packem_shared/provider.d-BQAGriz6.js";
+/** The context handed to a step resolver / skip predicate. */
+interface StepResolverContext<PayloadT> {
+  /** The validated trigger payload of the run. */
+  payload: PayloadT;
+}
+/** Resolves the payload sent by a channel step (or decides to skip it). */
+type StepResolver<PayloadT, ResultT> = (context: StepResolverContext<PayloadT>) => MaybePromise<ResultT>;
+/** Per-step options for a channel step. */
+interface ChannelStepOptions<PayloadT> {
+  /** Skip the send when this returns `true`; the step records `undefined`. */
+  skip?: (context: StepResolverContext<PayloadT>) => MaybePromise<boolean>;
+  /**
+  * Treat a `FailureReceipt` as a thrown error so the run fails and the step
+  * re-runs on the next resume/sweep. Defaults to `false`.
+  */
+  throwOnFailure?: boolean;
+}
+/**
+* A durable channel step. Resolves a channel payload and delivers it through the
+* bound {@link Notification} facade exactly once; the receipt is recorded and
+* returned on replay without re-sending. Returns `undefined` when `skip` matches.
+*
+* IMPORTANT: a delivery failure surfaces as a `FailureReceipt` (the facade does not
+* throw), so by default a failed send is **recorded as a completed step and not
+* retried** — inspect `receipt.successful`, or pass `throwOnFailure: true` to turn
+* a failure into a thrown error that re-runs the step on the next activation.
+*/
+type ChannelStep<ChannelT extends ChannelType, PayloadT> = (id: string, resolve: StepResolver<PayloadT, ChannelPayloadMap[ChannelT]>, options?: ChannelStepOptions<PayloadT>) => Promise<Receipt | undefined>;
+/**
+* The `step` object handed to a notification workflow body. Channel steps deliver
+* exactly once; `delay` pauses durably; `custom` is an escape hatch to the raw
+* engine step.
+*/
+interface NotificationStep<PayloadT> {
+  chat: ChannelStep<"chat", PayloadT>;
+  custom: <T>(id: string, function_: () => MaybePromise<T>) => Promise<T>;
+  delay: (id: string, duration: Duration) => Promise<void>;
+  email: ChannelStep<"email", PayloadT>;
+  inApp: ChannelStep<"inapp", PayloadT>;
+  push: ChannelStep<"push", PayloadT>;
+  sms: ChannelStep<"sms", PayloadT>;
+  webhook: ChannelStep<"webhook", PayloadT>;
+}
+/** The body of a notification workflow, driven by {@link NotificationStep}. */
+type NotificationWorkflowRun<PayloadT, OutputT> = (context: {
+  payload: PayloadT;
+  runId: string;
+  step: NotificationStep<PayloadT>;
+}) => MaybePromise<OutputT>;
+/** Config for {@link createNotificationWorkflow}: a {@link WorkflowConfig} whose `run` is notification-flavoured. */
+interface NotificationWorkflowConfig<PayloadT, OutputT> extends Omit<WorkflowConfig<PayloadT, OutputT>, "run"> {
+  run: NotificationWorkflowRun<PayloadT, OutputT>;
+}
+/**
+* Define a durable notification workflow on top of [`@visulima/workflow`](https://visulima.com/packages/workflow).
+*
+* The returned value is a plain `WorkflowDefinition`, so it plugs straight into a
+* workflow runtime (`createRuntime({ workflows: [wf] })` → `runtime.trigger(wf, payload)`).
+* Channel steps deliver through the bound `notification` facade exactly once.
+* @param notification The multi-channel facade messages are delivered through.
+* @param config The workflow id, optional payload schema, and notification-flavoured `run`.
+* @returns A {@link WorkflowDefinition} ready to register/trigger on a runtime.
+* @example
+* ```ts
+* const onComment = createNotificationWorkflow(notify, {
+*     id: "comment-posted",
+*     payload: z.object({ subscriberId: z.string(), author: z.string() }),
+*     run: async ({ step, payload }) => {
+*         await step.inApp("inbox", () => ({ to: payload.subscriberId, body: `${payload.author} commented` }));
+*         await step.delay("cooldown", { amount: 1, unit: "hours" });
+*         await step.email("nudge", () => ({ from: "x@y.com", to: payload.subscriberId, subject: "New comment", html: "<p>…</p>" }));
+*     },
+* });
+* ```
+*/
+declare const createNotificationWorkflow: <PayloadT = unknown, OutputT = unknown>(notification: Notification, config: NotificationWorkflowConfig<PayloadT, OutputT>) => WorkflowDefinition<PayloadT, OutputT>;
+export { type ChannelStep, type ChannelStepOptions, type NotificationStep, type NotificationWorkflowConfig, type NotificationWorkflowRun, type StepResolver, type StepResolverContext, createNotificationWorkflow };

package/dist/workflow/index.js

@@ -0,0 +1 @@
+import{default as a}from"../packem_shared/createNotificationWorkflow-B70OgeED.js";export{a as createNotificationWorkflow};

package/package.json

@@ -1,45 +1,285 @@
 {
-    "name": "@visulima/notification",
-    "version": "0.0.1",
-    "description": "A reusable, ESM-only, edge-ready multi-channel notification library — placeholder, full release coming soon.",
-    "keywords": [
-        "notification",
-        "notifications",
-        "multi-channel",
-        "visulima"
-    ],
-    "homepage": "https://visulima.com/packages/notification",
-    "bugs": "https://github.com/visulima/visulima/issues",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/visulima/visulima.git",
-        "directory": "packages/notification/notification"
-    },
-    "funding": [
-        {
-            "type": "github",
-            "url": "https://github.com/sponsors/prisis"
-        },
-        {
-            "type": "consulting",
-            "url": "https://anolilab.com/support"
-        }
-    ],
-    "license": "MIT",
-    "author": {
-        "name": "Daniel Bannert",
-        "email": "d.bannert@anolilab.de"
-    },
-    "sideEffects": false,
-    "type": "module",
-    "files": [
-        "README.md"
-    ],
-    "engines": {
-        "node": "^22.14.0 || >=24.10.0"
-    },
-    "publishConfig": {
-        "access": "public",
-        "provenance": false
+  "name": "@visulima/notification",
+  "version": "1.0.0-alpha.2",
+  "description": "A reusable, ESM-only, edge-ready multi-channel notification library with SMS, push, chat, in-app and webhook providers",
+  "keywords": [
+    "notification",
+    "notifications",
+    "multi-channel",
+    "sms",
+    "push",
+    "chat",
+    "in-app",
+    "webhook",
+    "twilio",
+    "vonage",
+    "plivo",
+    "aws-sns",
+    "sns",
+    "messagebird",
+    "fcm",
+    "apns",
+    "expo",
+    "web-push",
+    "vapid",
+    "opentelemetry",
+    "handlebars",
+    "liquid",
+    "slack",
+    "discord",
+    "ms-teams",
+    "telegram",
+    "failover",
+    "roundrobin",
+    "middleware",
+    "queue",
+    "visulima"
+  ],
+  "homepage": "https://visulima.com/packages/notification",
+  "bugs": "https://github.com/visulima/visulima/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/visulima/visulima.git",
+    "directory": "packages/notification/notification"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/prisis"
+    },
+    {
+      "type": "consulting",
+      "url": "https://anolilab.com/support"
+    }
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./providers/mock": {
+      "types": "./dist/providers/mock/index.d.ts",
+      "default": "./dist/providers/mock/index.js"
+    },
+    "./providers/twilio": {
+      "types": "./dist/providers/sms/twilio/index.d.ts",
+      "default": "./dist/providers/sms/twilio/index.js"
+    },
+    "./providers/vonage": {
+      "types": "./dist/providers/sms/vonage/index.d.ts",
+      "default": "./dist/providers/sms/vonage/index.js"
+    },
+    "./providers/plivo": {
+      "types": "./dist/providers/sms/plivo/index.d.ts",
+      "default": "./dist/providers/sms/plivo/index.js"
+    },
+    "./providers/messagebird": {
+      "types": "./dist/providers/sms/messagebird/index.d.ts",
+      "default": "./dist/providers/sms/messagebird/index.js"
+    },
+    "./providers/telnyx": {
+      "types": "./dist/providers/sms/telnyx/index.d.ts",
+      "default": "./dist/providers/sms/telnyx/index.js"
+    },
+    "./providers/slack": {
+      "types": "./dist/providers/chat/slack/index.d.ts",
+      "default": "./dist/providers/chat/slack/index.js"
+    },
+    "./providers/discord": {
+      "types": "./dist/providers/chat/discord/index.d.ts",
+      "default": "./dist/providers/chat/discord/index.js"
+    },
+    "./providers/msteams": {
+      "types": "./dist/providers/chat/msteams/index.d.ts",
+      "default": "./dist/providers/chat/msteams/index.js"
+    },
+    "./providers/telegram": {
+      "types": "./dist/providers/chat/telegram/index.d.ts",
+      "default": "./dist/providers/chat/telegram/index.js"
+    },
+    "./providers/expo": {
+      "types": "./dist/providers/push/expo/index.d.ts",
+      "default": "./dist/providers/push/expo/index.js"
+    },
+    "./providers/fcm": {
+      "types": "./dist/providers/push/fcm/index.d.ts",
+      "default": "./dist/providers/push/fcm/index.js"
+    },
+    "./providers/failover": {
+      "types": "./dist/providers/failover/index.d.ts",
+      "default": "./dist/providers/failover/index.js"
+    },
+    "./providers/roundrobin": {
+      "types": "./dist/providers/roundrobin/index.d.ts",
+      "default": "./dist/providers/roundrobin/index.js"
+    },
+    "./providers/webhook": {
+      "types": "./dist/providers/webhook/index.d.ts",
+      "default": "./dist/providers/webhook/index.js"
+    },
+    "./channels/email": {
+      "types": "./dist/channels/email/index.d.ts",
+      "default": "./dist/channels/email/index.js"
+    },
+    "./channels/inapp": {
+      "types": "./dist/channels/inapp/index.d.ts",
+      "default": "./dist/channels/inapp/index.js"
+    },
+    "./preferences": {
+      "types": "./dist/preferences/index.d.ts",
+      "default": "./dist/preferences/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware/index.d.ts",
+      "default": "./dist/middleware/index.js"
+    },
+    "./routing": {
+      "types": "./dist/routing/index.d.ts",
+      "default": "./dist/routing/index.js"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.ts",
+      "default": "./dist/events/index.js"
+    },
+    "./queue": {
+      "types": "./dist/queue/index.d.ts",
+      "default": "./dist/queue/index.js"
+    },
+    "./queue/unstorage": {
+      "types": "./dist/queue/unstorage-queue.d.ts",
+      "default": "./dist/queue/unstorage-queue.js"
+    },
+    "./queue/bullmq": {
+      "types": "./dist/queue/bullmq-queue.d.ts",
+      "default": "./dist/queue/bullmq-queue.js"
+    },
+    "./queue/pg-boss": {
+      "types": "./dist/queue/pg-boss-queue.d.ts",
+      "default": "./dist/queue/pg-boss-queue.js"
+    },
+    "./queue/sqs": {
+      "types": "./dist/queue/sqs-queue.d.ts",
+      "default": "./dist/queue/sqs-queue.js"
+    },
+    "./providers/sns": {
+      "types": "./dist/providers/sms/sns/index.d.ts",
+      "default": "./dist/providers/sms/sns/index.js"
+    },
+    "./providers/web-push": {
+      "types": "./dist/providers/push/web-push/index.d.ts",
+      "default": "./dist/providers/push/web-push/index.js"
+    },
+    "./providers/apns": {
+      "types": "./dist/providers/push/apns/index.d.ts",
+      "default": "./dist/providers/push/apns/index.js"
+    },
+    "./providers/opentelemetry": {
+      "types": "./dist/providers/opentelemetry/index.d.ts",
+      "default": "./dist/providers/opentelemetry/index.js"
+    },
+    "./webhooks": {
+      "types": "./dist/webhooks/index.d.ts",
+      "default": "./dist/webhooks/index.js"
+    },
+    "./template/string": {
+      "types": "./dist/template-engines/string.d.ts",
+      "default": "./dist/template-engines/string.js"
+    },
+    "./template/handlebars": {
+      "types": "./dist/template-engines/handlebars.d.ts",
+      "default": "./dist/template-engines/handlebars.js"
+    },
+    "./template/liquid": {
+      "types": "./dist/template-engines/liquid.d.ts",
+      "default": "./dist/template-engines/liquid.js"
+    },
+    "./utils/result": {
+      "types": "./dist/utils/result.d.ts",
+      "default": "./dist/utils/result.js"
+    },
+    "./workflow": {
+      "types": "./dist/workflow/index.d.ts",
+      "default": "./dist/workflow/index.js"
+    },
+    "./digest": {
+      "types": "./dist/digest/index.d.ts",
+      "default": "./dist/digest/index.js"
+    },
+    "./layouts": {
+      "types": "./dist/layouts/index.d.ts",
+      "default": "./dist/layouts/index.js"
+    },
+    "./i18n": {
+      "types": "./dist/i18n/index.d.ts",
+      "default": "./dist/i18n/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "@aws-sdk/client-sqs": "^3.0.0",
+    "@opentelemetry/api": "^1.0.0 || ^2.0.0",
+    "@visulima/email": "1.0.0-alpha.42",
+    "@visulima/workflow": "1.0.0-alpha.1",
+    "bullmq": "^5.0.0",
+    "croner": "^10.0.1",
+    "handlebars": "4.7.9",
+    "intl-messageformat": "^11.0.0",
+    "liquidjs": "^10.0.0",
+    "pg-boss": "^10.0.0",
+    "unstorage": "^1.13.0"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-sqs": {
+      "optional": true
+    },
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@visulima/email": {
+      "optional": true
+    },
+    "@visulima/workflow": {
+      "optional": true
+    },
+    "bullmq": {
+      "optional": true
+    },
+    "croner": {
+      "optional": true
+    },
+    "handlebars": {
+      "optional": true
+    },
+    "intl-messageformat": {
+      "optional": true
+    },
+    "liquidjs": {
+      "optional": true
+    },
+    "pg-boss": {
+      "optional": true
+    },
+    "unstorage": {
+      "optional": true
     }
-}
+  },
+  "engines": {
+    "node": "^22.14.0 || >=24.10.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}