@satorio/machinery 0.2.1

package/dist/publishing/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public entry to the publishing mechanism: the event publisher, bound to a
+ * topic or to one line on stdout. It gives you the `EventPublisher` port bound
+ * to SNS or to one JSON line on stdout, with the topic read from one prefixed
+ * variable and a loud stand in its place when nobody set it.
+ */
+export { snsMessageBodyOf } from './event-publisher.sns.js';
+export { stdoutLineOf } from './event-publisher.stdout.js';
+export { StdoutEventPublisherLive, snsEventPublisherLive } from './layer.js';
+export { DEFAULT_EVENT_CHANNEL, ENVIRONMENT, type SnsPublisherSettings, snsPublisherSettings, topicArnVariable, } from './settings.js';

package/dist/publishing/index.js

@@ -0,0 +1,10 @@
+/**
+ * Public entry to the publishing mechanism: the event publisher, bound to a
+ * topic or to one line on stdout. It gives you the `EventPublisher` port bound
+ * to SNS or to one JSON line on stdout, with the topic read from one prefixed
+ * variable and a loud stand in its place when nobody set it.
+ */
+export { snsMessageBodyOf } from './event-publisher.sns.js';
+export { stdoutLineOf } from './event-publisher.stdout.js';
+export { StdoutEventPublisherLive, snsEventPublisherLive } from './layer.js';
+export { DEFAULT_EVENT_CHANNEL, ENVIRONMENT, snsPublisherSettings, topicArnVariable, } from './settings.js';

package/dist/publishing/layer.d.ts

@@ -0,0 +1,25 @@
+import { EventPublisher } from '@satorio/machinery/ports';
+import { type ConfigError, Layer } from 'effect';
+import { type ClosableSnsTransport } from './event-publisher.sns.js';
+import { type SnsPublisherSettings } from './settings.js';
+/**
+ * An SNS publisher built from environment variables with the given
+ * prefix. With no topic set it mounts the loud stand and logs the one
+ * refusal every later publish repeats, so startup carries on and no
+ * event goes missing in silence. The transport is a parameter, so a test
+ * substitutes its own without touching the wiring.
+ *
+ * @internal
+ */
+export declare const snsEventPublisherFromEnvironmentLive: (variablePrefix: string, openTransport: (settings: SnsPublisherSettings) => ClosableSnsTransport) => Layer.Layer<EventPublisher, ConfigError.ConfigError>;
+/**
+ * The SNS publisher on the real AWS SDK transport, reading the variables
+ * this prefix names.
+ */
+export declare const snsEventPublisherLive: (variablePrefix: string) => Layer.Layer<EventPublisher, ConfigError.ConfigError>;
+/**
+ * The stdout publisher, mounted: one JSON line per event under the
+ * channel `EVENT_CHANNEL` names. Nothing here can refuse, so the layer
+ * carries no failure of its own.
+ */
+export declare const StdoutEventPublisherLive: Layer.Layer<EventPublisher>;

package/dist/publishing/layer.js

@@ -0,0 +1,39 @@
+import { refusalText } from '@satorio/machinery/core';
+import { EventPublisher } from '@satorio/machinery/ports';
+import { Console, Effect, Layer, Option } from 'effect';
+import { eventPublisherUnavailableWithoutConfiguration, makeSnsEventPublisher, openSnsTransport, scopedSnsTransport, } from './event-publisher.sns.js';
+import { makeStdoutEventPublisher } from './event-publisher.stdout.js';
+import { configuredTopicArn, eventChannelFromEnvironment, snsPublisherSettings, topicArnRefusal, } from './settings.js';
+/**
+ * An SNS publisher built from environment variables with the given
+ * prefix. With no topic set it mounts the loud stand and logs the one
+ * refusal every later publish repeats, so startup carries on and no
+ * event goes missing in silence. The transport is a parameter, so a test
+ * substitutes its own without touching the wiring.
+ *
+ * @internal
+ */
+export const snsEventPublisherFromEnvironmentLive = (variablePrefix, openTransport) => Layer.unwrapEffect(Effect.gen(function* () {
+    const configured = yield* configuredTopicArn(variablePrefix);
+    if (Option.isNone(configured)) {
+        const refusal = topicArnRefusal(variablePrefix);
+        yield* Effect.logError(refusalText(refusal));
+        return Layer.succeed(EventPublisher, eventPublisherUnavailableWithoutConfiguration(refusal));
+    }
+    return Layer.scoped(EventPublisher, Effect.gen(function* () {
+        const settings = yield* snsPublisherSettings(variablePrefix);
+        const transport = yield* scopedSnsTransport(() => openTransport(settings));
+        return makeSnsEventPublisher(transport, settings);
+    }));
+}));
+/**
+ * The SNS publisher on the real AWS SDK transport, reading the variables
+ * this prefix names.
+ */
+export const snsEventPublisherLive = (variablePrefix) => snsEventPublisherFromEnvironmentLive(variablePrefix, openSnsTransport);
+/**
+ * The stdout publisher, mounted: one JSON line per event under the
+ * channel `EVENT_CHANNEL` names. Nothing here can refuse, so the layer
+ * carries no failure of its own.
+ */
+export const StdoutEventPublisherLive = Layer.effect(EventPublisher, Effect.map(eventChannelFromEnvironment, (channel) => makeStdoutEventPublisher(channel, (line) => Console.log(line)))).pipe(Layer.orDie);

package/dist/publishing/settings.d.ts

@@ -0,0 +1,60 @@
+import { type EnvironmentEntry, type Refusal } from '@satorio/machinery/core';
+import { Config, type Option } from 'effect';
+/**
+ * The log channel the stdout publisher writes its events under when
+ * nobody names one. A log collector filters on this word, so it has to
+ * mean something on its own.
+ */
+export declare const DEFAULT_EVENT_CHANNEL = "machinery-integration-events";
+/**
+ * Builds the environment variable name from the prefix the application
+ * gives at mount time. A per-prefix name lets several topics share one
+ * process and stay readable: `EVENTS_TOPIC_ARN`, `AUDIT_TOPIC_ARN`, and
+ * so on.
+ */
+export declare const topicArnVariable: (variablePrefix: string) => string;
+/**
+ * What the SNS publisher needs before it can send: one topic, and the
+ * two variables the AWS SDK reads for itself when nobody names them.
+ */
+export interface SnsPublisherSettings {
+    readonly topicArn: string;
+    readonly region: Option.Option<string>;
+    readonly endpoint: Option.Option<string>;
+}
+/**
+ * The three parts a reader meets when the topic is not set. The mount
+ * desk logs this text and every publish of the loud stand fails with it,
+ * so an operator reads one sentence rather than two.
+ *
+ * @internal
+ */
+export declare const topicArnRefusal: (variablePrefix: string) => Refusal;
+/**
+ * Reads the topic without refusing, so the mount desk can put up the
+ * loud stand instead of failing service startup.
+ *
+ * @internal
+ */
+export declare const configuredTopicArn: (variablePrefix: string) => Config.Config<Option.Option<string>>;
+/**
+ * Every variable this adapter reads, and the one state each of them
+ * stands in. `<PREFIX>` is the prefix the application passes at mount
+ * time; `EVENT_CHANNEL` belongs to the stdout publisher, which serves
+ * one process and needs no prefix.
+ */
+export declare const ENVIRONMENT: readonly EnvironmentEntry[];
+/**
+ * Reads every variable the SNS publisher needs under one prefix. A
+ * missing or blank topic refuses in three parts; region and endpoint
+ * stay `Option.none`, and the SDK decides.
+ */
+export declare const snsPublisherSettings: (variablePrefix: string) => Config.Config<SnsPublisherSettings>;
+/**
+ * Reads the channel the stdout publisher writes under. Nobody has to set
+ * it: an unset channel takes the default rather than refusing, because a
+ * line on stdout is readable either way.
+ *
+ * @internal
+ */
+export declare const eventChannelFromEnvironment: Config.Config<string>;

package/dist/publishing/settings.js

@@ -0,0 +1,85 @@
+import { fallsBackTo, handedOn, optionalText, refuses, requiredText, } from '@satorio/machinery/core';
+import { Config } from 'effect';
+const TOPIC_ARN_SUFFIX = '_TOPIC_ARN';
+const EVENT_CHANNEL = 'EVENT_CHANNEL';
+const REGION = 'AWS_REGION';
+const ENDPOINT = 'AWS_ENDPOINT_URL';
+/**
+ * The log channel the stdout publisher writes its events under when
+ * nobody names one. A log collector filters on this word, so it has to
+ * mean something on its own.
+ */
+export const DEFAULT_EVENT_CHANNEL = 'machinery-integration-events';
+/**
+ * Builds the environment variable name from the prefix the application
+ * gives at mount time. A per-prefix name lets several topics share one
+ * process and stay readable: `EVENTS_TOPIC_ARN`, `AUDIT_TOPIC_ARN`, and
+ * so on.
+ */
+export const topicArnVariable = (variablePrefix) => `${variablePrefix}${TOPIC_ARN_SUFFIX}`;
+/**
+ * The three parts a reader meets when the topic is not set. The mount
+ * desk logs this text and every publish of the loud stand fails with it,
+ * so an operator reads one sentence rather than two.
+ *
+ * @internal
+ */
+export const topicArnRefusal = (variablePrefix) => ({
+    what: `${topicArnVariable(variablePrefix)} is not set, so this publisher has no topic.`,
+    why: 'One process publishes to several topics, each under its own prefix, so the publisher cannot guess which one you meant.',
+    whatToDo: `Set ${topicArnVariable(variablePrefix)} to the topic ARN from the AWS console or your .env, then start the service again.`,
+});
+/**
+ * Reads the topic without refusing, so the mount desk can put up the
+ * loud stand instead of failing service startup.
+ *
+ * @internal
+ */
+export const configuredTopicArn = (variablePrefix) => optionalText(topicArnVariable(variablePrefix));
+/**
+ * Every variable this adapter reads, and the one state each of them
+ * stands in. `<PREFIX>` is the prefix the application passes at mount
+ * time; `EVENT_CHANNEL` belongs to the stdout publisher, which serves
+ * one process and needs no prefix.
+ */
+export const ENVIRONMENT = [
+    {
+        name: TOPIC_ARN_SUFFIX,
+        prefixed: true,
+        what: 'The SNS topic this publisher sends events to.',
+        state: refuses(topicArnRefusal('<PREFIX>')),
+    },
+    {
+        name: EVENT_CHANNEL,
+        what: "The word a log collector filters the stdout publisher's lines by.",
+        state: fallsBackTo(DEFAULT_EVENT_CHANNEL),
+    },
+    {
+        name: REGION,
+        what: 'The region the SNS client talks to.',
+        state: handedOn('the AWS SDK finds its own region from the machine it runs on.'),
+    },
+    {
+        name: ENDPOINT,
+        what: 'A local stand to talk to instead of real SNS, such as localstack.',
+        state: handedOn('the client goes to the real SNS for the region it found.'),
+    },
+];
+/**
+ * Reads every variable the SNS publisher needs under one prefix. A
+ * missing or blank topic refuses in three parts; region and endpoint
+ * stay `Option.none`, and the SDK decides.
+ */
+export const snsPublisherSettings = (variablePrefix) => Config.all({
+    topicArn: requiredText(topicArnVariable(variablePrefix), topicArnRefusal(variablePrefix)),
+    region: optionalText(REGION),
+    endpoint: optionalText(ENDPOINT),
+});
+/**
+ * Reads the channel the stdout publisher writes under. Nobody has to set
+ * it: an unset channel takes the default rather than refusing, because a
+ * line on stdout is readable either way.
+ *
+ * @internal
+ */
+export const eventChannelFromEnvironment = Config.string(EVENT_CHANNEL).pipe(Config.withDefault(DEFAULT_EVENT_CHANNEL));

package/dist/queue/consumer.d.ts

@@ -0,0 +1,91 @@
+import { QueueMessageSource, type QueueMessageSourceUnavailableError } from '@satorio/machinery/ports';
+import type { DateTime } from 'effect';
+import { Effect, Schedule, Stream } from 'effect';
+import type { QueueMessageNotDecodableError } from './failures.js';
+import { type PayloadDecoder } from './message-codec.js';
+/**
+ * One message as a handler meets it: the envelope's own fields, and the
+ * decoded event itself.
+ */
+export interface IncomingQueueMessage<A> {
+    readonly eventId: string;
+    readonly eventType: string;
+    readonly schemaVersion: number;
+    readonly occurredAt: DateTime.Utc;
+    readonly event: A;
+}
+/**
+ * Why a message goes back on the queue: it never decoded, or the handler
+ * rejected it.
+ */
+export type RedeliveryReason = {
+    readonly _tag: 'MessageNotDecodable';
+    readonly error: QueueMessageNotDecodableError;
+} | {
+    readonly _tag: 'HandlerRejectedMessage';
+    readonly error: unknown;
+};
+/**
+ * The reason for a message that never decoded.
+ */
+export declare const messageNotDecodable: (error: QueueMessageNotDecodableError) => RedeliveryReason;
+/**
+ * The reason for a message the handler itself rejected.
+ */
+export declare const handlerRejectedMessage: (error: unknown) => RedeliveryReason;
+/**
+ * The fate of one message has exactly three endings: acknowledged, left
+ * for redelivery, or refused permanently. There is no fourth, silent
+ * outcome.
+ */
+export type QueueMessageOutcome = {
+    readonly _tag: 'MessageAcknowledged';
+    readonly messageId: string;
+} | {
+    readonly _tag: 'MessageLeftForRedelivery';
+    readonly messageId: string;
+    readonly reason: RedeliveryReason;
+} | {
+    readonly _tag: 'MessageRefusedPermanently';
+    readonly messageId: string;
+    readonly eventId: string;
+    readonly refusal: unknown;
+};
+/**
+ * The fate of a message the handler took, so the queue may drop it.
+ */
+export declare const messageAcknowledged: (messageId: string) => QueueMessageOutcome;
+/**
+ * The fate of a message that goes back on the queue, with the reason it did.
+ */
+export declare const messageLeftForRedelivery: (messageId: string, reason: RedeliveryReason) => QueueMessageOutcome;
+/**
+ * The fate of a message no retry can help, so the platform's own redrive takes
+ * it from here.
+ */
+export declare const messageRefusedPermanently: (messageId: string, eventId: string, refusal: unknown) => QueueMessageOutcome;
+/**
+ * How a consumer waits and tries again while the queue itself does not answer.
+ */
+export type QueueRetrySchedule = Schedule.Schedule<unknown, QueueMessageSourceUnavailableError>;
+/**
+ * The waiting a consumer keeps when a service names no schedule of its own:
+ * growing pauses, jittered, and a limit on how often it tries.
+ */
+export declare const defaultQueueRetrySchedule: QueueRetrySchedule;
+/**
+ * What a consumer needs to turn a queue message into work. It names how to
+ * decode a payload, what to do with it, how to wait out a queue that is down,
+ * and which refusals no retry can help.
+ */
+export interface QueueMessageConsumerOptions<A, E, R> {
+    readonly decodePayload: PayloadDecoder<A>;
+    readonly handle: (input: IncomingQueueMessage<A>) => Effect.Effect<unknown, E, R>;
+    readonly retrySchedule: QueueRetrySchedule;
+    readonly isPermanentRefusal?: (error: E) => boolean;
+}
+/**
+ * Reads messages off the queue and hands each one to the handler, answering
+ * with the fate of every message it took.
+ */
+export declare const consumeQueueMessages: <A, E, R>(options: QueueMessageConsumerOptions<A, E, R>) => Stream.Stream<QueueMessageOutcome, QueueMessageSourceUnavailableError, R | QueueMessageSource>;

package/dist/queue/consumer.js

@@ -0,0 +1,92 @@
+import { QueueMessageSource, } from '@satorio/machinery/ports';
+import { Chunk, Duration, Effect, Match, Schedule, Stream } from 'effect';
+import { decodeQueueMessageBody } from './message-codec.js';
+/**
+ * The reason for a message that never decoded.
+ */
+export const messageNotDecodable = (error) => ({
+    _tag: 'MessageNotDecodable',
+    error,
+});
+/**
+ * The reason for a message the handler itself rejected.
+ */
+export const handlerRejectedMessage = (error) => ({
+    _tag: 'HandlerRejectedMessage',
+    error,
+});
+/**
+ * The fate of a message the handler took, so the queue may drop it.
+ */
+export const messageAcknowledged = (messageId) => ({
+    _tag: 'MessageAcknowledged',
+    messageId,
+});
+/**
+ * The fate of a message that goes back on the queue, with the reason it did.
+ */
+export const messageLeftForRedelivery = (messageId, reason) => ({
+    _tag: 'MessageLeftForRedelivery',
+    messageId,
+    reason,
+});
+/**
+ * The fate of a message no retry can help, so the platform's own redrive takes
+ * it from here.
+ */
+export const messageRefusedPermanently = (messageId, eventId, refusal) => ({
+    _tag: 'MessageRefusedPermanently',
+    messageId,
+    eventId,
+    refusal,
+});
+/**
+ * The waiting a consumer keeps when a service names no schedule of its own:
+ * growing pauses, jittered, and a limit on how often it tries.
+ */
+export const defaultQueueRetrySchedule = Schedule.exponential(Duration.millis(200), 2).pipe(Schedule.union(Schedule.spaced(Duration.seconds(30))), Schedule.jittered, Schedule.intersect(Schedule.recurs(10)));
+const useCaseInputFrom = (envelope, event) => ({
+    eventId: envelope.eventId,
+    eventType: envelope.eventType,
+    schemaVersion: envelope.schemaVersion,
+    occurredAt: envelope.occurredAt,
+    event,
+});
+const outcomeOf = (options, message) => decodeQueueMessageBody(message.body).pipe(Effect.flatMap((envelope) => options
+    .decodePayload(envelope.schemaVersion, envelope.payload)
+    .pipe(Effect.map((event) => useCaseInputFrom(envelope, event)))), Effect.matchEffect({
+    onFailure: (error) => {
+        const reason = messageNotDecodable(error);
+        return Effect.logWarning('Queue message: left for redelivery', {
+            messageId: message.messageId,
+            reason: reason._tag,
+            error,
+        }).pipe(Effect.as(messageLeftForRedelivery(message.messageId, reason)));
+    },
+    onSuccess: (input) => options.handle(input).pipe(Effect.matchEffect({
+        onFailure: (error) => {
+            if (options.isPermanentRefusal?.(error) === true) {
+                return Effect.logError('Queue message: event refused permanently, message goes to the platform DLQ after the redrive limit runs out', {
+                    eventId: input.eventId,
+                    eventType: input.eventType,
+                    refusal: error,
+                }).pipe(Effect.as(messageRefusedPermanently(message.messageId, input.eventId, error)));
+            }
+            const reason = handlerRejectedMessage(error);
+            return Effect.logWarning('Queue message: left for redelivery', {
+                messageId: message.messageId,
+                reason: reason._tag,
+                error,
+            }).pipe(Effect.as(messageLeftForRedelivery(message.messageId, reason)));
+        },
+        onSuccess: () => Effect.succeed(messageAcknowledged(message.messageId)),
+    })),
+}));
+const applyOutcome = (source, message, retrySchedule, outcome) => Match.value(outcome).pipe(Match.tag('MessageAcknowledged', () => source
+    .acknowledge(message.receiptHandle)
+    .pipe(Effect.retry(retrySchedule))), Match.tag('MessageLeftForRedelivery', () => Effect.void), Match.tag('MessageRefusedPermanently', () => Effect.void), Match.exhaustive);
+/**
+ * Reads messages off the queue and hands each one to the handler, answering
+ * with the fate of every message it took.
+ */
+export const consumeQueueMessages = (options) => Stream.unwrap(Effect.map(QueueMessageSource, (source) => Stream.repeatEffectChunk(source.receive.pipe(Effect.retry(options.retrySchedule), Effect.map(Chunk.fromIterable))).pipe(Stream.mapEffect((message) => outcomeOf(options, message).pipe(Effect.tap((outcome) => applyOutcome(source, message, options.retrySchedule, outcome)))))));

package/dist/queue/envelope.d.ts

@@ -0,0 +1,39 @@
+import type { VersionedEventDefinition } from '@satorio/machinery/workflow';
+import { Effect, Schema } from 'effect';
+import { UnknownEventTypeError } from './failures.js';
+/**
+ * The version a stored payload was shaped by: a whole number above zero, and
+ * never anything else.
+ */
+export declare const SchemaVersion: Schema.brand<Schema.filter<typeof Schema.Int>, "SchemaVersion">;
+export type SchemaVersion = typeof SchemaVersion.Type;
+/**
+ * The shared queue contract every message travels in.
+ *
+ * The shared queue contract: who sent it (eventId), what it is (eventType),
+ * which schema shaped it (schemaVersion), when it happened (occurredAt), and
+ * the content itself (payload). The payload is the service's concern; the
+ * envelope is the machinery's concern.
+ */
+export declare const StoredEventEnvelope: Schema.Struct<{
+    eventId: typeof Schema.NonEmptyTrimmedString;
+    eventType: typeof Schema.NonEmptyTrimmedString;
+    schemaVersion: Schema.brand<Schema.filter<typeof Schema.Int>, "SchemaVersion">;
+    occurredAt: typeof Schema.DateTimeUtc;
+    payload: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+export type StoredEventEnvelope = typeof StoredEventEnvelope.Type;
+/**
+ * What a service's own list of event definitions offers: whether an event type
+ * is known, and the definition behind it.
+ */
+export interface EventDefinitionRegistry<S extends Schema.Schema.AnyNoContext> {
+    readonly knows: (eventType: string) => boolean;
+    readonly definitionFor: (eventType: string) => Effect.Effect<VersionedEventDefinition<S>, UnknownEventTypeError>;
+}
+/**
+ * Builds a registry of known event definitions. Your service lists its
+ * definitions; the machinery gives lookup and a loud refusal for an
+ * unknown type.
+ */
+export declare const eventDefinitionRegistry: <S extends Schema.Schema.AnyNoContext>(definitions: readonly VersionedEventDefinition<S>[]) => EventDefinitionRegistry<S>;

package/dist/queue/envelope.js

@@ -0,0 +1,39 @@
+import { Effect, Schema } from 'effect';
+import { UnknownEventTypeError } from './failures.js';
+/**
+ * The version a stored payload was shaped by: a whole number above zero, and
+ * never anything else.
+ */
+export const SchemaVersion = Schema.Int.pipe(Schema.positive(), Schema.brand('SchemaVersion')).annotations({ identifier: 'SchemaVersion' });
+/**
+ * The shared queue contract every message travels in.
+ *
+ * The shared queue contract: who sent it (eventId), what it is (eventType),
+ * which schema shaped it (schemaVersion), when it happened (occurredAt), and
+ * the content itself (payload). The payload is the service's concern; the
+ * envelope is the machinery's concern.
+ */
+export const StoredEventEnvelope = Schema.Struct({
+    eventId: Schema.NonEmptyTrimmedString,
+    eventType: Schema.NonEmptyTrimmedString,
+    schemaVersion: SchemaVersion,
+    occurredAt: Schema.DateTimeUtc,
+    payload: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+}).annotations({ identifier: 'StoredEventEnvelope' });
+/**
+ * Builds a registry of known event definitions. Your service lists its
+ * definitions; the machinery gives lookup and a loud refusal for an
+ * unknown type.
+ */
+export const eventDefinitionRegistry = (definitions) => {
+    const byEventType = new Map(definitions.map((definition) => [definition.eventType, definition]));
+    return {
+        knows: (eventType) => byEventType.has(eventType),
+        definitionFor: (eventType) => {
+            const found = byEventType.get(eventType);
+            return found === undefined
+                ? Effect.fail(new UnknownEventTypeError({ eventType }))
+                : Effect.succeed(found);
+        },
+    };
+};

package/dist/queue/failures.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The stage a message fell over at: the envelope every message shares,
+ * or the payload one event type defines.
+ *
+ * @internal
+ */
+export type QueueMessageDecodingStage = 'envelope' | 'payload';
+declare const QueueMessageNotDecodableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "QueueMessageNotDecodableError";
+} & Readonly<A>;
+/**
+ * A message whose text this service cannot turn into an event. The stage
+ * says whether the shared envelope or the event's own payload was the
+ * part that would not decode.
+ */
+export declare class QueueMessageNotDecodableError extends QueueMessageNotDecodableError_base<{
+    readonly stage: QueueMessageDecodingStage;
+    readonly cause: unknown;
+}> {
+}
+declare const UnknownEventTypeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "UnknownEventTypeError";
+} & Readonly<A>;
+/**
+ * A message naming an event type this service never registered. The
+ * registry refuses loudly rather than guessing which definition was
+ * meant.
+ */
+export declare class UnknownEventTypeError extends UnknownEventTypeError_base<{
+    readonly eventType: string;
+}> {
+}
+export {};

package/dist/queue/failures.js

@@ -0,0 +1,15 @@
+import { Data } from 'effect';
+/**
+ * A message whose text this service cannot turn into an event. The stage
+ * says whether the shared envelope or the event's own payload was the
+ * part that would not decode.
+ */
+export class QueueMessageNotDecodableError extends Data.TaggedError('QueueMessageNotDecodableError') {
+}
+/**
+ * A message naming an event type this service never registered. The
+ * registry refuses loudly rather than guessing which definition was
+ * meant.
+ */
+export class UnknownEventTypeError extends Data.TaggedError('UnknownEventTypeError') {
+}

package/dist/queue/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public entry to the queue mechanism: the envelope a message travels in, and
+ * the consumer that decides its fate. It gives you the envelope every message
+ * carries, the decoder that opens it, the consumer that decides each message's
+ * fate, and the SQS source and producer read from one prefix of environment
+ * variables.
+ */
+export { consumeQueueMessages, defaultQueueRetrySchedule, handlerRejectedMessage, type IncomingQueueMessage, messageAcknowledged, messageLeftForRedelivery, messageNotDecodable, messageRefusedPermanently, type QueueMessageConsumerOptions, type QueueMessageOutcome, type QueueRetrySchedule, type RedeliveryReason, } from './consumer.js';
+export { type EventDefinitionRegistry, eventDefinitionRegistry, SchemaVersion, StoredEventEnvelope, } from './envelope.js';
+export { QueueMessageNotDecodableError, UnknownEventTypeError, } from './failures.js';
+export { sqsQueueMessageProducerLive, sqsQueueMessageSourceLive, } from './layer.js';
+export { decodeQueueMessageBody, type PayloadDecoder, payloadDecoderFor, QueueMessageBody, queueMessageBodyOf, } from './message-codec.js';
+export { queueReadinessCheck } from './readiness.js';
+export { ENVIRONMENT, type QueueConsumerSettings, type QueueProducerSettings, queueConsumerSettings, queueProducerSettings, queueUrlVariable, SQS_DEFAULT_VISIBILITY_TIMEOUT_SECONDS, } from './settings.js';

package/dist/queue/index.js

@@ -0,0 +1,14 @@
+/**
+ * Public entry to the queue mechanism: the envelope a message travels in, and
+ * the consumer that decides its fate. It gives you the envelope every message
+ * carries, the decoder that opens it, the consumer that decides each message's
+ * fate, and the SQS source and producer read from one prefix of environment
+ * variables.
+ */
+export { consumeQueueMessages, defaultQueueRetrySchedule, handlerRejectedMessage, messageAcknowledged, messageLeftForRedelivery, messageNotDecodable, messageRefusedPermanently, } from './consumer.js';
+export { eventDefinitionRegistry, SchemaVersion, StoredEventEnvelope, } from './envelope.js';
+export { QueueMessageNotDecodableError, UnknownEventTypeError, } from './failures.js';
+export { sqsQueueMessageProducerLive, sqsQueueMessageSourceLive, } from './layer.js';
+export { decodeQueueMessageBody, payloadDecoderFor, QueueMessageBody, queueMessageBodyOf, } from './message-codec.js';
+export { queueReadinessCheck } from './readiness.js';
+export { ENVIRONMENT, queueConsumerSettings, queueProducerSettings, queueUrlVariable, SQS_DEFAULT_VISIBILITY_TIMEOUT_SECONDS, } from './settings.js';

package/dist/queue/layer.d.ts

@@ -0,0 +1,33 @@
+import { QueueMessageProducer, QueueMessageSource } from '@satorio/machinery/ports';
+import { type ConfigError, Layer } from 'effect';
+import { type ClosableSqsSendTransport } from './queue-message-producer.js';
+import { type ClosableSqsTransport } from './queue-message-source.js';
+import { type QueueConsumerSettings, type QueueProducerSettings } from './settings.js';
+/**
+ * A message source built from environment variables with the given
+ * prefix. With no queue URL set it mounts the loud stand and logs the
+ * one refusal every later receive repeats, so startup carries on and
+ * nothing goes missing in silence. The transport is a parameter, so a
+ * test substitutes its own without touching the wiring.
+ *
+ * @internal
+ */
+export declare const queueMessageSourceFromEnvironmentLive: (variablePrefix: string, openTransport: (settings: QueueConsumerSettings) => ClosableSqsTransport) => Layer.Layer<QueueMessageSource, ConfigError.ConfigError>;
+/**
+ * The message source on the real AWS SDK transport, reading the
+ * variables this prefix names.
+ */
+export declare const sqsQueueMessageSourceLive: (variablePrefix: string) => Layer.Layer<QueueMessageSource, ConfigError.ConfigError>;
+/**
+ * A message producer built from environment variables with the given
+ * prefix, mounting the loud stand when no queue URL is set. The
+ * transport is a parameter for the same reason the source's is.
+ *
+ * @internal
+ */
+export declare const queueMessageProducerFromEnvironmentLive: (variablePrefix: string, openTransport: (settings: QueueProducerSettings) => ClosableSqsSendTransport) => Layer.Layer<QueueMessageProducer, ConfigError.ConfigError>;
+/**
+ * The message producer on the real AWS SDK transport, reading the
+ * variables this prefix names.
+ */
+export declare const sqsQueueMessageProducerLive: (variablePrefix: string) => Layer.Layer<QueueMessageProducer, ConfigError.ConfigError>;