@panorama-industries/effect-vercel-queue 0.0.0-stage → 0.2.0

package/src/implementation/queue-config-live.ts

@@ -0,0 +1,178 @@
+import type { DeploymentId } from "@panorama-industries/effect-vercel-core";
+
+import { VercelRegion, VercelSystemEnv } from "@panorama-industries/effect-vercel-core";
+import { Config, ConfigProvider, Effect, Layer, Option, Redacted, Schema } from "effect";
+
+import { QueueAuth, QueueConfig } from "../contracts/queue-config.ts";
+
+/** Values that replace what {@link QueueConfigLive} derives from the environment. */
+export interface QueueConfigOptions {
+  /** Default region; otherwise `VERCEL_REGION`, then `iad1`. */
+  readonly region?: VercelRegion;
+
+  /** Base URL per region; replaces both the regional default and the local broker URL. */
+  readonly baseUrl?: (region: VercelRegion) => URL;
+
+  /** Fixed bearer token used instead of OIDC or the local broker token. */
+  readonly token?: string | Redacted.Redacted<string>;
+
+  /**
+   * Deployment that sends are pinned to and consumer calls name; otherwise `VERCEL_DEPLOYMENT_ID`.
+   * `"unpinned"` sends no deployment at all, so any deployment's consumers may receive messages.
+   */
+  readonly deploymentId?: DeploymentId | "unpinned";
+
+  /** Extra headers sent with every request. */
+  readonly headers?: Readonly<Record<string, string>>;
+}
+
+const defaultRegion = VercelRegion.make("iad1");
+
+const semver =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+[\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*)?$/;
+
+const supportsLocalQueueBroker = (version: string): boolean => {
+  if (version.length > 256) return false;
+  const match = semver.exec(version);
+  if (match === null) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  const prerelease = match[4];
+  if (
+    ![major, minor, patch].every(Number.isSafeInteger) ||
+    prerelease?.split(".").some((part) => /^0\d+$/.test(part))
+  ) {
+    return false;
+  }
+  return (
+    major > 59 ||
+    (major === 59 && (minor > 26 || (minor === 26 && (patch > 0 || prerelease === undefined))))
+  );
+};
+
+const configError = (message: string) =>
+  new Config.ConfigError(new ConfigProvider.SourceError({ message }));
+
+const nonEmpty = (name: string) =>
+  Config.option(Config.String(name)).pipe(Config.map(Option.filter((value) => value !== "")));
+
+const decodeUrl = Schema.decodeUnknownOption(Schema.URLFromString);
+
+const regionalBaseUrl = (region: VercelRegion) => new URL(`https://${region}.vercel-queue.com`);
+
+const stripTrailingSlashes = (path: string) => path.replace(/\/+$/, "");
+
+const sameEndpoint = (a: URL, b: URL) =>
+  a.origin === b.origin && stripTrailingSlashes(a.pathname) === stripTrailingSlashes(b.pathname);
+
+const missingDeploymentId = configError(
+  "No deployment ID available. VERCEL_DEPLOYMENT_ID is not set.\n\n" +
+    "This usually means the code is running outside a Vercel deployment " +
+    "(e.g. during build or in a non-Vercel environment).\n\n" +
+    "To fix this, provide an explicit deployment ID:\n" +
+    '  queueConfigLayer({ deploymentId: DeploymentId.make("dpl_xxx") })\n' +
+    "Or explicitly opt out of deployment pinning:\n" +
+    '  queueConfigLayer({ deploymentId: "unpinned" })',
+);
+
+const missingLocalToken = configError(
+  "Missing local queue token. VERCEL_QUEUE_BASE_URL selects a local broker, " +
+    "but VERCEL_QUEUE_TOKEN is not set. Start your app with a Vercel CLI " +
+    "version that supports local Queues, or provide an explicit token.",
+);
+
+const localToken = Config.option(Config.Redacted("VERCEL_QUEUE_TOKEN")).pipe(
+  Effect.map(Option.filter((token) => Redacted.value(token) !== "")),
+  Effect.flatMap(
+    Option.match({ onNone: () => Effect.fail(missingLocalToken), onSome: Effect.succeed }),
+  ),
+);
+
+const invalidLocalUrl = configError("Invalid VERCEL_QUEUE_BASE_URL: expected an absolute URL");
+
+const resolveQueueConfig = Effect.fnUntraced(function* (options: QueueConfigOptions) {
+  const env = yield* VercelSystemEnv;
+  const devMode = env.isDevelopment && Option.isNone(env.deploymentId);
+
+  const region =
+    options.region ??
+    Option.getOrUndefined(env.region) ??
+    (yield* Effect.as(
+      devMode
+        ? Effect.void
+        : Effect.logWarning(
+            `Queue region not detected; defaulting to "${defaultRegion}". On Vercel it comes ` +
+              "from VERCEL_REGION. Set it explicitly with queueConfigLayer({ region }) to " +
+              "silence this warning.",
+          ),
+      defaultRegion,
+    ));
+
+  const injectedUrl =
+    devMode && Option.exists(env.cliVersion, supportsLocalQueueBroker)
+      ? yield* nonEmpty("VERCEL_QUEUE_BASE_URL")
+      : Option.none<string>();
+  const localUrl = Option.flatMap(injectedUrl, decodeUrl);
+  if (Option.isSome(injectedUrl) && Option.isNone(localUrl) && options.baseUrl === undefined) {
+    return yield* Effect.fail(invalidLocalUrl);
+  }
+
+  const baseUrl =
+    options.baseUrl ??
+    Option.match(localUrl, {
+      onNone: () => regionalBaseUrl,
+      onSome: (url) => () => new URL(url),
+    });
+  const usesLocalBroker = Option.exists(localUrl, (url) => sameEndpoint(baseUrl(region), url));
+
+  const auth =
+    options.token !== undefined
+      ? QueueAuth.Token({
+          token: Redacted.isRedacted(options.token) ? options.token : Redacted.make(options.token),
+        })
+      : usesLocalBroker
+        ? QueueAuth.Token({ token: yield* localToken })
+        : QueueAuth.Oidc();
+
+  const deploymentId =
+    options.deploymentId === "unpinned" || usesLocalBroker || devMode
+      ? Option.none<DeploymentId>()
+      : Option.some(
+          yield* Option.match(
+            Option.orElse(Option.fromUndefinedOr(options.deploymentId), () => env.deploymentId),
+            { onNone: () => Effect.fail(missingDeploymentId), onSome: Effect.succeed },
+          ),
+        );
+
+  return QueueConfig.of({
+    region,
+    baseUrl,
+    auth,
+    deploymentId,
+    pinSends: Option.isSome(deploymentId),
+    headers: options.headers ?? {},
+  });
+});
+
+/**
+ * Builds {@link QueueConfig} from the environment, with any given values taking precedence.
+ *
+ * Outside development, construction fails with a `ConfigError` when no deployment ID is known and
+ * the options do not opt out with `deploymentId: "unpinned"`.
+ */
+export const queueConfigLayer = (
+  options: QueueConfigOptions = {},
+): Layer.Layer<QueueConfig, Config.ConfigError, VercelSystemEnv> =>
+  Layer.effect(QueueConfig, resolveQueueConfig(options));
+
+/**
+ * Derives {@link QueueConfig} from `VercelSystemEnv`, `VERCEL_QUEUE_BASE_URL` and
+ * `VERCEL_QUEUE_TOKEN`.
+ *
+ * On Vercel it targets `https://{region}.vercel-queue.com` with OIDC and pins sends to the
+ * deployment, failing with a `ConfigError` when `VERCEL_DEPLOYMENT_ID` is missing. Under
+ * `vercel dev` (CLI 59.26.0 or later) it targets the local broker with its token.
+ */
+export const QueueConfigLive: Layer.Layer<QueueConfig, Config.ConfigError, VercelSystemEnv> =
+  queueConfigLayer();

package/src/implementation/queue-consumer-live.ts

@@ -0,0 +1,112 @@
+import type { HttpServerError } from "effect/http";
+
+import { Cause, Effect, Layer, Option, Predicate } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+
+import type { ConsumeOptions, MessageHandler } from "../contracts/message-handling.ts";
+import type { QueueReceiveByIdError } from "../contracts/queue-api.ts";
+import type { MessageId } from "../contracts/queue-domain.ts";
+import type { Topic } from "../contracts/topic.ts";
+import type { Delivery } from "../internal/process.ts";
+
+import { QueueApi } from "../contracts/queue-api.ts";
+import { QueueConfig } from "../contracts/queue-config.ts";
+import { QueueConsumer } from "../contracts/queue-consumer.ts";
+import { inlineDelivery, MalformedCloudEvent, parseCallback } from "../internal/cloud-event.ts";
+import { leaseVisibilityTimeout } from "../internal/lease.ts";
+import { processDelivery, producerLinks, withProcessSpan } from "../internal/process.ts";
+
+const skipped = (reason: "already_processed" | "not_available", messageId: MessageId) =>
+  Effect.logDebug(
+    `Queue callback skipped (${reason}) for message ${messageId}: ` +
+      "the message was already handled or is no longer available to this consumer.",
+  ).pipe(Effect.as(HttpServerResponse.jsonUnsafe({ status: "skipped", reason, messageId })));
+
+const failed = (cause: Cause.Cause<unknown>) =>
+  Cause.hasInterruptsOnly(cause)
+    ? Effect.failCause(cause as Cause.Cause<never>)
+    : Effect.logError("Queue callback error", cause).pipe(
+        Effect.as(
+          HttpServerResponse.jsonUnsafe(
+            { error: "Failed to process queue message" },
+            { status: 500 },
+          ),
+        ),
+      );
+
+/**
+ * Implements {@link QueueConsumer} for push delivery, as `@vercel/queue`'s `handleCallback`.
+ *
+ * Requires `QueueApi` and `QueueConfig`. Leases default to 5 minutes (at least 30 seconds) and are
+ * renewed while the handler runs. Responses: 200 `{status:"success"}`; 200 `{status:"skipped"}`
+ * when the message was already processed (410) or is held elsewhere (409); 400 `{error}` for a
+ * malformed CloudEvent; 500 otherwise, so the queue redelivers.
+ */
+export const QueueConsumerLive = Layer.effect(
+  QueueConsumer,
+  Effect.gen(function* () {
+    const api = yield* QueueApi;
+    const config = yield* QueueConfig;
+
+    const handler = <A, I, E, R, R2 = never>(
+      topic: Topic<A, I>,
+      handle: MessageHandler<A, E, R>,
+      options: ConsumeOptions<E, R2> = {},
+    ) =>
+      Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const parsed = yield* parseCallback(request.headers, request.text);
+        const region = Option.getOrElse(parsed.region, () => config.region);
+
+        const delivery: Effect.Effect<
+          Delivery,
+          QueueReceiveByIdError | HttpServerError.HttpServerError | MalformedCloudEvent
+        > = Option.match(parsed.inline, {
+          onNone: () =>
+            api
+              .receiveById(parsed.topic, parsed.consumerGroup, parsed.messageId, {
+                visibilityTimeout: leaseVisibilityTimeout(options.visibilityTimeout),
+                region,
+              })
+              .pipe(Effect.map((message) => ({ message, deadline: Option.none() }))),
+          onSome: (inline) =>
+            Effect.flatMap(request.arrayBuffer, (buffer) =>
+              buffer.byteLength === 0
+                ? Effect.fail(
+                    new MalformedCloudEvent({
+                      message: "Binary mode callback with receipt handle is missing payload",
+                    }),
+                  )
+                : inlineDelivery(parsed, inline, region, topic.contentType, new Uint8Array(buffer)),
+            ),
+        });
+
+        return yield* delivery.pipe(
+          Effect.flatMap((received) => processDelivery(api, topic, handle, options, received)),
+          withProcessSpan(producerLinks(request.headers)),
+          Effect.as(HttpServerResponse.jsonUnsafe({ status: "success" })),
+          Effect.catch((error) => {
+            if (Predicate.isTagged(error, "MessageAlreadyProcessed")) {
+              return skipped("already_processed", parsed.messageId);
+            }
+            if (Predicate.isTagged(error, "MessageNotAvailable")) {
+              return skipped("not_available", parsed.messageId);
+            }
+            return Effect.fail(error);
+          }),
+        );
+      }).pipe(
+        Effect.catch((error) =>
+          error instanceof MalformedCloudEvent
+            ? Effect.logError("Queue callback error", error).pipe(
+                Effect.as(HttpServerResponse.jsonUnsafe({ error: error.message }, { status: 400 })),
+              )
+            : Effect.fail(error),
+        ),
+        Effect.catchCause(failed),
+        Effect.annotateLogs({ module: "QueueConsumer" }),
+      );
+
+    return QueueConsumer.of({ handler });
+  }),
+);

package/src/implementation/queue-live.ts

@@ -0,0 +1,32 @@
+import type { Config } from "effect";
+import type { HttpClient } from "effect/http";
+
+import { VercelOidcLive, VercelSystemEnvLive } from "@panorama-industries/effect-vercel-core";
+import { Layer } from "effect";
+
+import type { QueueConsumer } from "../contracts/queue-consumer.ts";
+import type { QueuePoller } from "../contracts/queue-poller.ts";
+import type { QueueProducer } from "../contracts/queue-producer.ts";
+
+import { QueueApiLive } from "./queue-api-live.ts";
+import { QueueConfigLive } from "./queue-config-live.ts";
+import { QueueConsumerLive } from "./queue-consumer-live.ts";
+import { QueuePollerLive } from "./queue-poller-live.ts";
+import { QueueProducerLive } from "./queue-producer-live.ts";
+
+/**
+ * Producer, push consumer and poller configured from the Vercel environment, authenticated with
+ * the function's OIDC token. Provide an `HttpClient`, e.g. `FetchHttpClient.layer`.
+ *
+ * Compose the individual layers instead to override configuration (`queueConfigLayer`) or
+ * credentials.
+ */
+export const QueueLive: Layer.Layer<
+  QueueProducer | QueueConsumer | QueuePoller,
+  Config.ConfigError,
+  HttpClient.HttpClient
+> = Layer.mergeAll(QueueProducerLive, QueueConsumerLive, QueuePollerLive).pipe(
+  Layer.provideMerge(QueueApiLive),
+  Layer.provide(Layer.mergeAll(QueueConfigLive, VercelOidcLive)),
+  Layer.provide(VercelSystemEnvLive),
+);

package/src/implementation/queue-poller-live.ts

@@ -0,0 +1,130 @@
+import { Effect, Exit, Layer, Option, Predicate, Scope } from "effect";
+
+import type { ConsumeOptions, MessageHandler } from "../contracts/message-handling.ts";
+import type {
+  ConsumerGroupName,
+  MessageAlreadyProcessed,
+  MessageId,
+  MessageNotAvailable,
+  MessageNotFound,
+  ReceivedMessage,
+} from "../contracts/queue-domain.ts";
+import type { PollByIdOptions, PollOptions } from "../contracts/queue-poller.ts";
+import type { Topic } from "../contracts/topic.ts";
+
+import { QueueApi } from "../contracts/queue-api.ts";
+import { MessageCorrupted, PayloadDecodeFailed } from "../contracts/queue-domain.ts";
+import { QueuePoller, ReceiveOutcome } from "../contracts/queue-poller.ts";
+import { keepLeaseAlive, leaseVisibilityTimeout } from "../internal/lease.ts";
+import { processDelivery, withProcessSpan } from "../internal/process.ts";
+
+/**
+ * Implements {@link QueuePoller}, as `@vercel/queue`'s `PollingQueueClient.receive`.
+ *
+ * Requires `QueueApi`. Leases default to 5 minutes (at least 30 seconds) and are renewed while each
+ * handler runs. A batch is handled concurrently up to `concurrency` (unbounded by default), and
+ * messages waiting their turn keep their leases renewed. When handlers fail, every message is still
+ * settled and the first failure in delivery order is returned. An undecodable payload whose error
+ * policy answers `Fail` is reported as `MessageCorrupted`.
+ */
+export const QueuePollerLive = Layer.effect(
+  QueuePoller,
+  Effect.gen(function* () {
+    const api = yield* QueueApi;
+
+    const handleOne = <A, I, E, R, R2>(
+      topic: Topic<A, I>,
+      handler: MessageHandler<A, E, R>,
+      options: ConsumeOptions<E, R2>,
+      message: ReceivedMessage,
+    ) =>
+      processDelivery(api, topic, handler, options, {
+        message,
+        deadline: Option.none(),
+      }).pipe(
+        withProcessSpan([]),
+        Effect.mapError((error) =>
+          error instanceof PayloadDecodeFailed
+            ? new MessageCorrupted({ messageId: error.messageId, message: error.message })
+            : error,
+        ),
+      );
+
+    const receive = <A, I, E, R, R2 = never>(
+      topic: Topic<A, I>,
+      consumerGroup: ConsumerGroupName,
+      handler: MessageHandler<A, E, R>,
+      options: PollOptions<E, R2> = {},
+    ) =>
+      Effect.gen(function* () {
+        const messages = yield* api.receive(topic.name, consumerGroup, {
+          visibilityTimeout: leaseVisibilityTimeout(options.visibilityTimeout),
+          ...(options.limit === undefined ? {} : { limit: options.limit }),
+          ...(options.cursorFallback === undefined
+            ? {}
+            : { cursorFallback: options.cursorFallback }),
+          ...(options.region === undefined ? {} : { region: options.region }),
+        });
+        if (messages.length === 0) return ReceiveOutcome.Empty();
+        const timeout = leaseVisibilityTimeout(options.visibilityTimeout);
+        const waiting = yield* Effect.forEach(messages, (message) =>
+          Effect.gen(function* () {
+            const scope = yield* Scope.make();
+            yield* keepLeaseAlive(api, message.handle, timeout, Option.none()).pipe(
+              Scope.provide(scope),
+            );
+            return { message, scope };
+          }),
+        );
+        const exits = yield* Effect.forEach(
+          waiting,
+          ({ message, scope }) =>
+            Scope.close(scope, Exit.void).pipe(
+              Effect.andThen(Effect.exit(handleOne(topic, handler, options, message))),
+            ),
+          { concurrency: options.concurrency ?? "unbounded" },
+        ).pipe(
+          Effect.ensuring(Effect.forEach(waiting, ({ scope }) => Scope.close(scope, Exit.void))),
+        );
+        const failure = exits.find(Exit.isFailure);
+        if (failure !== undefined) return yield* Effect.failCause(failure.cause);
+        return ReceiveOutcome.Processed({ count: messages.length });
+      });
+
+    const receiveById = <A, I, E, R, R2 = never>(
+      topic: Topic<A, I>,
+      consumerGroup: ConsumerGroupName,
+      messageId: MessageId,
+      handler: MessageHandler<A, E, R>,
+      options: PollByIdOptions<E, R2> = {},
+    ) =>
+      api
+        .receiveById(topic.name, consumerGroup, messageId, {
+          visibilityTimeout: leaseVisibilityTimeout(options.visibilityTimeout),
+          ...(options.region === undefined ? {} : { region: options.region }),
+        })
+        .pipe(
+          Effect.flatMap((message) => handleOne(topic, handler, options, message)),
+          Effect.as(ReceiveOutcome.Processed({ count: 1 })),
+          Effect.catch((error) => {
+            if (Predicate.isTagged(error, "MessageNotFound")) {
+              return Effect.succeed<ReceiveOutcome>(ReceiveOutcome.NotFound({ messageId }));
+            }
+            if (Predicate.isTagged(error, "MessageNotAvailable")) {
+              return Effect.succeed<ReceiveOutcome>(ReceiveOutcome.NotAvailable({ messageId }));
+            }
+            if (Predicate.isTagged(error, "MessageAlreadyProcessed")) {
+              return Effect.succeed<ReceiveOutcome>(ReceiveOutcome.AlreadyProcessed({ messageId }));
+            }
+            return Effect.fail(
+              error as Exclude<
+                typeof error,
+                MessageNotFound | MessageNotAvailable | MessageAlreadyProcessed
+              >,
+            );
+          }),
+        );
+
+    return QueuePoller.of({ receive, receiveById });
+  }),
+);

package/src/implementation/queue-producer-live.ts

@@ -0,0 +1,89 @@
+import { Array, Effect, Layer, Schema } from "effect";
+
+import type { PublishOptions } from "../contracts/queue-api.ts";
+import type { BatchEntry } from "../contracts/queue-producer.ts";
+import type { Topic } from "../contracts/topic.ts";
+
+import { QueueApi, SendResult } from "../contracts/queue-api.ts";
+import { BatchSizeOutOfRange, PayloadEncodeFailed } from "../contracts/queue-domain.ts";
+import { QueueProducer } from "../contracts/queue-producer.ts";
+
+const maxBatchSize = 100;
+
+const encode = <A, I>(topic: Topic<A, I>, payload: A) =>
+  Schema.encodeEffect(topic.wire)(payload).pipe(
+    Effect.mapError(
+      (error) => new PayloadEncodeFailed({ topic: topic.name, message: error.message }),
+    ),
+  );
+
+const publishOptions = (options: PublishOptions): PublishOptions => ({
+  ...(options.idempotencyKey !== undefined && { idempotencyKey: options.idempotencyKey }),
+  ...(options.retention !== undefined && { retention: options.retention }),
+  ...(options.delay !== undefined && { delay: options.delay }),
+  ...(options.headers !== undefined && { headers: options.headers }),
+  ...(options.experimentalConcurrencyKey !== undefined && {
+    experimentalConcurrencyKey: options.experimentalConcurrencyKey,
+  }),
+});
+
+const sendSpan = (topic: Topic.Any) =>
+  Effect.withSpan("vqs.send", {
+    kind: "producer",
+    attributes: {
+      "messaging.system": "vercel-queue",
+      "messaging.destination.name": topic.name,
+    },
+  });
+
+/**
+ * Implements {@link QueueProducer} over `QueueApi`: encodes payloads with the topic's schema and
+ * publishes them in a `vqs.send` producer span.
+ */
+export const QueueProducerLive: Layer.Layer<QueueProducer, never, QueueApi> = Layer.effect(
+  QueueProducer,
+  Effect.gen(function* () {
+    const api = yield* QueueApi;
+
+    const send = Effect.fnUntraced(function* <A, I>(
+      topic: Topic<A, I>,
+      payload: A,
+      options: PublishOptions = {},
+    ) {
+      const body = yield* encode(topic, payload);
+      return yield* api
+        .send(topic.name, { ...publishOptions(options), body, contentType: topic.contentType })
+        .pipe(
+          Effect.tap(
+            SendResult.$match({
+              Sent: ({ messageId }) =>
+                Effect.annotateCurrentSpan("messaging.message.id", messageId),
+              Deferred: () => Effect.void,
+            }),
+          ),
+          sendSpan(topic),
+        );
+    });
+
+    const sendBatch = Effect.fnUntraced(function* <A, I>(
+      topic: Topic<A, I>,
+      entries: Array.NonEmptyReadonlyArray<BatchEntry<A>>,
+    ) {
+      if (entries.length === 0 || entries.length > maxBatchSize) {
+        return yield* new BatchSizeOutOfRange({ size: entries.length, maximum: maxBatchSize });
+      }
+      const toMessage = (entry: BatchEntry<A>) =>
+        Effect.map(encode(topic, entry.payload), (body) => ({
+          ...publishOptions(entry),
+          body,
+          contentType: topic.contentType,
+        }));
+      const [head, ...tail] = entries;
+      const first = yield* toMessage(head);
+      const rest = yield* Effect.forEach(tail, toMessage);
+      return yield* api.sendBatch(topic.name, [first, ...rest]).pipe(sendSpan(topic));
+    });
+
+    return QueueProducer.of({ send, sendBatch });
+  }),
+);

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from "./contracts/message-handling.ts";
+export * from "./contracts/queue-api.ts";
+export * from "./contracts/queue-config.ts";
+export * from "./contracts/queue-consumer.ts";
+export * from "./contracts/queue-domain.ts";
+export * from "./contracts/queue-poller.ts";
+export * from "./contracts/queue-producer.ts";
+export * from "./contracts/topic.ts";
+export { QueueApiLive } from "./implementation/queue-api-live.ts";
+export {
+  QueueConfigLive,
+  type QueueConfigOptions,
+  queueConfigLayer,
+} from "./implementation/queue-config-live.ts";
+export { QueueConsumerLive } from "./implementation/queue-consumer-live.ts";
+export { QueueLive } from "./implementation/queue-live.ts";
+export { QueuePollerLive } from "./implementation/queue-poller-live.ts";
+export { QueueProducerLive } from "./implementation/queue-producer-live.ts";
+export { retryOnSchedule } from "./retry-policy.ts";