@satorio/machinery 0.2.1

package/dist/ports/queue-message-producer.d.ts

@@ -0,0 +1,26 @@
+import { Context, type Effect } from 'effect';
+declare const QueueMessageProducerUnavailableError_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: "QueueMessageProducerUnavailableError";
+} & Readonly<A>;
+/**
+ * The queue producer did not answer; `operation` names the call and `cause`
+ * carries the driver's own error.
+ */
+export declare class QueueMessageProducerUnavailableError extends QueueMessageProducerUnavailableError_base<{
+    readonly operation: string;
+    readonly cause: unknown;
+}> {
+}
+/**
+ * What a producer offers: one call that puts a message body onto the queue.
+ */
+export interface QueueMessageProducerShape {
+    readonly send: (body: string) => Effect.Effect<void, QueueMessageProducerUnavailableError>;
+}
+declare const QueueMessageProducer_base: Context.TagClass<QueueMessageProducer, "QueueMessageProducer", QueueMessageProducerShape>;
+/**
+ * The port a use case asks for when it sends a message to a queue.
+ */
+export declare class QueueMessageProducer extends QueueMessageProducer_base {
+}
+export {};

package/dist/ports/queue-message-producer.js

@@ -0,0 +1,12 @@
+import { Context, Data } from 'effect';
+/**
+ * The queue producer did not answer; `operation` names the call and `cause`
+ * carries the driver's own error.
+ */
+export class QueueMessageProducerUnavailableError extends Data.TaggedError('QueueMessageProducerUnavailableError') {
+}
+/**
+ * The port a use case asks for when it sends a message to a queue.
+ */
+export class QueueMessageProducer extends Context.Tag('QueueMessageProducer')() {
+}

package/dist/ports/queue-message-source.d.ts

@@ -0,0 +1,39 @@
+import { Context, type Effect } from 'effect';
+/**
+ * One message as the queue hands it over: its own id, the receipt an
+ * acknowledgement quotes, and the body, still text.
+ */
+export interface RawQueueMessage {
+    readonly messageId: string;
+    readonly receiptHandle: string;
+    readonly body: string;
+}
+declare const QueueMessageSourceUnavailableError_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: "QueueMessageSourceUnavailableError";
+} & Readonly<A>;
+/**
+ * The queue source did not answer; `operation` names the call and `cause`
+ * carries the driver's own error.
+ */
+export declare class QueueMessageSourceUnavailableError extends QueueMessageSourceUnavailableError_base<{
+    readonly operation: string;
+    readonly cause: unknown;
+}> {
+}
+/**
+ * A source of queue messages: it receives a batch and acknowledges what was
+ * taken. The app never knows whether SQS, a test stub, or another queue
+ * stands behind it.
+ */
+export interface QueueMessageSourceShape {
+    readonly receive: Effect.Effect<readonly RawQueueMessage[], QueueMessageSourceUnavailableError>;
+    readonly acknowledge: (receiptHandle: string) => Effect.Effect<void, QueueMessageSourceUnavailableError>;
+}
+declare const QueueMessageSource_base: Context.TagClass<QueueMessageSource, "QueueMessageSource", QueueMessageSourceShape>;
+/**
+ * The port a consumer asks for when it receives messages from a queue and
+ * acknowledges what it took.
+ */
+export declare class QueueMessageSource extends QueueMessageSource_base {
+}
+export {};

package/dist/ports/queue-message-source.js

@@ -0,0 +1,13 @@
+import { Context, Data } from 'effect';
+/**
+ * The queue source did not answer; `operation` names the call and `cause`
+ * carries the driver's own error.
+ */
+export class QueueMessageSourceUnavailableError extends Data.TaggedError('QueueMessageSourceUnavailableError') {
+}
+/**
+ * The port a consumer asks for when it receives messages from a queue and
+ * acknowledges what it took.
+ */
+export class QueueMessageSource extends Context.Tag('QueueMessageSource')() {
+}

package/dist/ports/readiness-probe.d.ts

@@ -0,0 +1,27 @@
+import { Context, type Effect } from 'effect';
+declare const DatabaseDidNotAnswerError_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: "DatabaseDidNotAnswerError";
+} & Readonly<A>;
+/**
+ * The readiness check against the database did not come back; `reason` says
+ * what stopped it.
+ */
+export declare class DatabaseDidNotAnswerError extends DatabaseDidNotAnswerError_base<{
+    readonly reason: string;
+}> {
+}
+/**
+ * What a readiness probe offers: one check that the database answers, so the
+ * endpoint reports a dependency rather than a guess.
+ */
+export interface ReadinessProbeShape {
+    readonly verifyDatabaseAnswers: Effect.Effect<void, DatabaseDidNotAnswerError>;
+}
+declare const ReadinessProbe_base: Context.TagClass<ReadinessProbe, "ReadinessProbe", ReadinessProbeShape>;
+/**
+ * The port the readiness endpoint asks for when it has to say whether this
+ * service can take traffic.
+ */
+export declare class ReadinessProbe extends ReadinessProbe_base {
+}
+export {};

package/dist/ports/readiness-probe.js

@@ -0,0 +1,13 @@
+import { Context, Data } from 'effect';
+/**
+ * The readiness check against the database did not come back; `reason` says
+ * what stopped it.
+ */
+export class DatabaseDidNotAnswerError extends Data.TaggedError('DatabaseDidNotAnswerError') {
+}
+/**
+ * The port the readiness endpoint asks for when it has to say whether this
+ * service can take traffic.
+ */
+export class ReadinessProbe extends Context.Tag('ReadinessProbe')() {
+}

package/dist/ports/transaction-boundary.d.ts

@@ -0,0 +1,28 @@
+import { Context, type Effect } from 'effect';
+declare const TransactionBoundaryUnavailableError_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: "TransactionBoundaryUnavailableError";
+} & Readonly<A>;
+/**
+ * The transaction driver did not answer; `operation` names the call and
+ * `cause` carries the driver's own error.
+ */
+export declare class TransactionBoundaryUnavailableError extends TransactionBoundaryUnavailableError_base<{
+    readonly operation: string;
+    readonly cause: unknown;
+}> {
+}
+/**
+ * What a transaction boundary offers: one call that runs work inside a
+ * transaction, and rolls the whole of it back when the work fails.
+ */
+export interface TransactionBoundaryShape {
+    readonly inTransaction: <A, E, R>(work: Effect.Effect<A, E, R>) => Effect.Effect<A, E | TransactionBoundaryUnavailableError, R>;
+}
+declare const TransactionBoundary_base: Context.TagClass<TransactionBoundary, "TransactionBoundary", TransactionBoundaryShape>;
+/**
+ * The port a use case asks for when its writes must land together or not at
+ * all.
+ */
+export declare class TransactionBoundary extends TransactionBoundary_base {
+}
+export {};

package/dist/ports/transaction-boundary.js

@@ -0,0 +1,13 @@
+import { Context, Data } from 'effect';
+/**
+ * The transaction driver did not answer; `operation` names the call and
+ * `cause` carries the driver's own error.
+ */
+export class TransactionBoundaryUnavailableError extends Data.TaggedError('TransactionBoundaryUnavailableError') {
+}
+/**
+ * The port a use case asks for when its writes must land together or not at
+ * all.
+ */
+export class TransactionBoundary extends Context.Tag('TransactionBoundary')() {
+}

package/dist/postgres/client.d.ts

@@ -0,0 +1,51 @@
+import type { ConnectionOptions } from 'node:tls';
+import { FileSystem } from '@effect/platform';
+import type { PlatformError } from '@effect/platform/Error';
+import { SqlError } from '@effect/sql/SqlError';
+import { Effect, Option, type Scope } from 'effect';
+import { Pool, type PoolConfig } from 'pg';
+import type { PostgresConnectionSettings } from './settings.js';
+/**
+ * Reads what the driver needs to encrypt the connection: `false` to talk
+ * in the clear, otherwise whether the chain must verify and, when a root
+ * certificate is named, the certificate itself.
+ *
+ * @internal
+ */
+export declare const sslOptionsFor: (settings: PostgresConnectionSettings) => Effect.Effect<boolean | ConnectionOptions, PlatformError, FileSystem.FileSystem>;
+/**
+ * Opens the channel a connection asks a fresh IAM token from. It holds
+ * nothing to release — signing a token is arithmetic over credentials,
+ * not a socket — so it has no scoped twin, and the region stays optional
+ * because the AWS SDK finds its own when nobody names one.
+ *
+ * @internal
+ */
+export declare const openIamTokenTransport: (settings: PostgresConnectionSettings, region: Option.Option<string>) => (() => Promise<string>);
+/**
+ * Builds the pool options for one service connection: the address, the
+ * schema as `search_path`, the name `pg_stat_activity` shows, and
+ * whichever of the two ways of proving who you are is in force.
+ *
+ * @internal
+ */
+export declare const poolOptionsFor: (settings: PostgresConnectionSettings, ssl: boolean | ConnectionOptions) => PoolConfig;
+/**
+ * Opens the connection pool. This is the one place in this mechanism
+ * where the `pg` driver is constructed, so every path to a live socket
+ * goes through `scopedPostgresTransport` and closes with its scope.
+ *
+ * @internal
+ */
+export declare const openPostgresTransport: (options: PoolConfig) => Pool;
+/**
+ * Builds an effect that acquires a Postgres connection pool and releases it
+ * when its scope closes. Pass a function that builds `PoolConfig` from
+ * settings and SSL options, plus the message to use if the pool fails to
+ * open; call the result with settings and SSL options to run it. One shape
+ * serves both the service and the migration runner — `optionsFor` and the
+ * failure message are the only two parts that vary between them.
+ *
+ * @internal
+ */
+export declare const scopedPostgresTransport: (optionsFor: (settings: PostgresConnectionSettings, ssl: boolean | ConnectionOptions) => PoolConfig, poolCreationFailureMessage: string) => (settings: PostgresConnectionSettings, ssl: boolean | ConnectionOptions) => Effect.Effect<Pool, SqlError, Scope.Scope>;

package/dist/postgres/client.js

@@ -0,0 +1,81 @@
+import { Signer } from '@aws-sdk/rds-signer';
+import { FileSystem } from '@effect/platform';
+import { SqlError } from '@effect/sql/SqlError';
+import { Effect, Match, Option, Redacted } from 'effect';
+import { Pool } from 'pg';
+const encryptionIsDisabled = (sslMode) => sslMode === 'disable';
+const certificateChainMustBeVerified = (sslMode) => sslMode === 'verify-ca' || sslMode === 'verify-full';
+/**
+ * Reads what the driver needs to encrypt the connection: `false` to talk
+ * in the clear, otherwise whether the chain must verify and, when a root
+ * certificate is named, the certificate itself.
+ *
+ * @internal
+ */
+export const sslOptionsFor = (settings) => Effect.gen(function* () {
+    if (encryptionIsDisabled(settings.sslMode))
+        return false;
+    const rejectUnauthorized = certificateChainMustBeVerified(settings.sslMode);
+    if (Option.isNone(settings.sslRootCertificatePath))
+        return { rejectUnauthorized };
+    const fileSystem = yield* FileSystem.FileSystem;
+    const ca = yield* fileSystem.readFileString(settings.sslRootCertificatePath.value);
+    return { rejectUnauthorized, ca };
+});
+/**
+ * Opens the channel a connection asks a fresh IAM token from. It holds
+ * nothing to release — signing a token is arithmetic over credentials,
+ * not a socket — so it has no scoped twin, and the region stays optional
+ * because the AWS SDK finds its own when nobody names one.
+ *
+ * @internal
+ */
+export const openIamTokenTransport = (settings, region) => {
+    const signer = new Signer({
+        hostname: settings.host,
+        port: settings.port,
+        username: settings.user,
+        ...(Option.isSome(region) ? { region: region.value } : {}),
+    });
+    return () => signer.getAuthToken();
+};
+const passwordFor = (settings) => Match.value(settings.authentication).pipe(Match.tag('AwsIamAuthentication', ({ region }) => openIamTokenTransport(settings, region)), Match.tag('PasswordAuthentication', ({ password }) => Redacted.value(password)), Match.exhaustive);
+/**
+ * Builds the pool options for one service connection: the address, the
+ * schema as `search_path`, the name `pg_stat_activity` shows, and
+ * whichever of the two ways of proving who you are is in force.
+ *
+ * @internal
+ */
+export const poolOptionsFor = (settings, ssl) => ({
+    host: settings.host,
+    port: settings.port,
+    user: settings.user,
+    database: settings.database,
+    options: `-c search_path=${settings.schema}`,
+    application_name: settings.applicationName,
+    ssl,
+    password: passwordFor(settings),
+});
+/**
+ * Opens the connection pool. This is the one place in this mechanism
+ * where the `pg` driver is constructed, so every path to a live socket
+ * goes through `scopedPostgresTransport` and closes with its scope.
+ *
+ * @internal
+ */
+export const openPostgresTransport = (options) => new Pool(options);
+/**
+ * Builds an effect that acquires a Postgres connection pool and releases it
+ * when its scope closes. Pass a function that builds `PoolConfig` from
+ * settings and SSL options, plus the message to use if the pool fails to
+ * open; call the result with settings and SSL options to run it. One shape
+ * serves both the service and the migration runner — `optionsFor` and the
+ * failure message are the only two parts that vary between them.
+ *
+ * @internal
+ */
+export const scopedPostgresTransport = (optionsFor, poolCreationFailureMessage) => (settings, ssl) => Effect.acquireRelease(Effect.try({
+    try: () => openPostgresTransport(optionsFor(settings, ssl)),
+    catch: (cause) => new SqlError({ cause, message: poolCreationFailureMessage }),
+}), (pool) => Effect.promise(() => pool.end()).pipe(Effect.orDie));

package/dist/postgres/document-number-counter.d.ts

@@ -0,0 +1,14 @@
+import { PgClient } from '@effect/sql-pg';
+import { DocumentNumberCounterUnavailableError } from '@satorio/machinery/ports';
+import { Effect } from 'effect';
+/**
+ * Builds the counter on the service's own pool. One statement takes the
+ * next count and reads it back, so two callers asking for the same
+ * client and month at the same instant queue behind one row rather than
+ * both reading the same number.
+ *
+ * @internal
+ */
+export declare const makePgDocumentNumberCounter: Effect.Effect<{
+    nextCount: (input: import("@satorio/machinery/ports").DocumentNumberCountInput) => Effect.Effect<number, DocumentNumberCounterUnavailableError>;
+}, never, PgClient.PgClient>;

package/dist/postgres/document-number-counter.js

@@ -0,0 +1,27 @@
+import { PgClient } from '@effect/sql-pg';
+import { DocumentNumberCounterUnavailableError, portUnavailable, } from '@satorio/machinery/ports';
+import { Effect } from 'effect';
+/**
+ * Builds the counter on the service's own pool. One statement takes the
+ * next count and reads it back, so two callers asking for the same
+ * client and month at the same instant queue behind one row rather than
+ * both reading the same number.
+ *
+ * @internal
+ */
+export const makePgDocumentNumberCounter = Effect.gen(function* () {
+    const sql = yield* PgClient.PgClient;
+    const unavailable = portUnavailable(DocumentNumberCounterUnavailableError);
+    const nextCount = (input) => Effect.gen(function* () {
+        const rows = yield* sql `
+        INSERT INTO document_number_counter
+          (client_code, reporting_month, issued)
+        VALUES (${input.clientCode}::text, ${input.reportingMonth}::text, 1)
+        ON CONFLICT (client_code, reporting_month) DO UPDATE
+          SET issued = document_number_counter.issued + 1
+        RETURNING issued
+      `;
+        return rows[0]?.issued ?? 0;
+    }).pipe(Effect.catchTag('SqlError', unavailable('nextCount')));
+    return { nextCount };
+});

package/dist/postgres/failures.d.ts

@@ -0,0 +1,28 @@
+declare const MigrationLockBusyError_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: "MigrationLockBusyError";
+} & Readonly<A>;
+/**
+ * A second process already holds the migration lock and did not let go
+ * within the retry window. Nothing was applied; the run is safe to
+ * repeat once the other process finishes.
+ */
+export declare class MigrationLockBusyError extends MigrationLockBusyError_base<{
+    readonly lockName: string;
+}> {
+}
+declare const ClaimRaceWindowMissedError_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: "ClaimRaceWindowMissedError";
+} & Readonly<A>;
+/**
+ * The claim statement took the lock and read who won it in one go, and
+ * the read saw neither. That happens when a competing claim has won but
+ * has not committed as of this statement's own snapshot. The registry
+ * retries a fixed number of times and never lets this failure out.
+ *
+ * @internal
+ */
+export declare class ClaimRaceWindowMissedError extends ClaimRaceWindowMissedError_base<{
+    readonly eventId: string;
+}> {
+}
+export {};

package/dist/postgres/failures.js

@@ -0,0 +1,18 @@
+import { Data } from 'effect';
+/**
+ * A second process already holds the migration lock and did not let go
+ * within the retry window. Nothing was applied; the run is safe to
+ * repeat once the other process finishes.
+ */
+export class MigrationLockBusyError extends Data.TaggedError('MigrationLockBusyError') {
+}
+/**
+ * The claim statement took the lock and read who won it in one go, and
+ * the read saw neither. That happens when a competing claim has won but
+ * has not committed as of this statement's own snapshot. The registry
+ * retries a fixed number of times and never lets this failure out.
+ *
+ * @internal
+ */
+export class ClaimRaceWindowMissedError extends Data.TaggedError('ClaimRaceWindowMissedError') {
+}

package/dist/postgres/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public entry to the postgres mechanism: every port this machinery defines,
+ * bound to a real database. It gives you every port this machinery defines,
+ * bound to a real database — the transaction boundary, the exactly-once claim,
+ * the outbox, the document number counter and the readiness probe — with the
+ * connection read from the environment, a migration runner that holds an
+ * advisory lock, and the helpers a store reaches for when a SQL failure has to
+ * become a domain failure or a JSON document has to reach a `jsonb` column.
+ */
+export { MigrationLockBusyError } from './failures.js';
+export { jsonbValue } from './jsonb-value.js';
+export { MigrationPgClientLive, PgDocumentNumberCounterLive, PgIntegrationEventOutboxLive, PgProcessedEventRegistryLive, PgReadinessProbeLive, PgTransactionBoundaryLive, PostgresClientLive, type PostgresPorts, PostgresPortsLive, PostgresPortsOnBunLive, } from './layer.js';
+export { type AdvisoryLock, holdingAdvisoryLock, postgresAdvisoryLock, } from './migrations/advisory-lock.js';
+export { applyMigrations, MACHINERY_MIGRATIONS_DIRECTORY, MIGRATION_LOCK_NAME, migrationLockNameFor, reportApplied, } from './migrations/runner.js';
+export { READINESS_QUERY_DEADLINE_MILLIS, READINESS_REASON_WHEN_THE_DATABASE_STAYS_SILENT, READINESS_REASON_WHEN_THE_QUERY_TIMES_OUT, readinessProbeAsking, } from './readiness-probe.js';
+export { configProviderPreferring, DEFAULT_APPLICATION_NAME, DEFAULT_AUTH_MODE, DEFAULT_POSTGRES_PORT, DEFAULT_POSTGRES_SCHEMA, DEFAULT_POSTGRES_SSL_MODE, ENVIRONMENT, POSTGRES_SSL_MODES, type PostgresAuthentication, type PostgresConnectionSettings, type PostgresSslMode, postgresConnectionSettings, schemaDefaultingTo, } from './settings.js';
+export { isUniqueViolation } from './sql-failure.js';
+export { firstRow, onUniqueViolation } from './store-failure.js';

package/dist/postgres/index.js

@@ -0,0 +1,18 @@
+/**
+ * Public entry to the postgres mechanism: every port this machinery defines,
+ * bound to a real database. It gives you every port this machinery defines,
+ * bound to a real database — the transaction boundary, the exactly-once claim,
+ * the outbox, the document number counter and the readiness probe — with the
+ * connection read from the environment, a migration runner that holds an
+ * advisory lock, and the helpers a store reaches for when a SQL failure has to
+ * become a domain failure or a JSON document has to reach a `jsonb` column.
+ */
+export { MigrationLockBusyError } from './failures.js';
+export { jsonbValue } from './jsonb-value.js';
+export { MigrationPgClientLive, PgDocumentNumberCounterLive, PgIntegrationEventOutboxLive, PgProcessedEventRegistryLive, PgReadinessProbeLive, PgTransactionBoundaryLive, PostgresClientLive, PostgresPortsLive, PostgresPortsOnBunLive, } from './layer.js';
+export { holdingAdvisoryLock, postgresAdvisoryLock, } from './migrations/advisory-lock.js';
+export { applyMigrations, MACHINERY_MIGRATIONS_DIRECTORY, MIGRATION_LOCK_NAME, migrationLockNameFor, reportApplied, } from './migrations/runner.js';
+export { READINESS_QUERY_DEADLINE_MILLIS, READINESS_REASON_WHEN_THE_DATABASE_STAYS_SILENT, READINESS_REASON_WHEN_THE_QUERY_TIMES_OUT, readinessProbeAsking, } from './readiness-probe.js';
+export { configProviderPreferring, DEFAULT_APPLICATION_NAME, DEFAULT_AUTH_MODE, DEFAULT_POSTGRES_PORT, DEFAULT_POSTGRES_SCHEMA, DEFAULT_POSTGRES_SSL_MODE, ENVIRONMENT, POSTGRES_SSL_MODES, postgresConnectionSettings, schemaDefaultingTo, } from './settings.js';
+export { isUniqueViolation } from './sql-failure.js';
+export { firstRow, onUniqueViolation } from './store-failure.js';

package/dist/postgres/integration-event-outbox.d.ts

@@ -0,0 +1,15 @@
+import { PgClient } from '@effect/sql-pg';
+import { IntegrationEventOutboxUnavailableError, type OutboxMessage } from '@satorio/machinery/ports';
+import { Effect } from 'effect';
+/**
+ * Builds the outbox on the service's own pool: an insert that ignores a
+ * repeat, a read of what is still undelivered, and a stamp that marks a
+ * batch handed on.
+ *
+ * @internal
+ */
+export declare const makePgIntegrationEventOutbox: Effect.Effect<{
+    enqueue: (messages: readonly OutboxMessage[]) => Effect.Effect<void, IntegrationEventOutboxUnavailableError>;
+    pending: (limit: number) => Effect.Effect<readonly OutboxMessage[], IntegrationEventOutboxUnavailableError>;
+    markDispatched: (messageIds: readonly string[]) => Effect.Effect<void, IntegrationEventOutboxUnavailableError>;
+}, never, PgClient.PgClient>;

package/dist/postgres/integration-event-outbox.js

@@ -0,0 +1,60 @@
+import { PgClient } from '@effect/sql-pg';
+import { IntegrationEventOutboxUnavailableError, portUnavailable, } from '@satorio/machinery/ports';
+import { DateTime, Effect } from 'effect';
+import { jsonbValue } from './jsonb-value.js';
+const outboxMessageOf = (row) => ({
+    messageId: row.messageId,
+    eventType: row.eventType,
+    schemaVersion: row.schemaVersion,
+    occurredAt: DateTime.unsafeMake(row.occurredAt),
+    payload: row.payload,
+});
+/**
+ * Builds the outbox on the service's own pool: an insert that ignores a
+ * repeat, a read of what is still undelivered, and a stamp that marks a
+ * batch handed on.
+ *
+ * @internal
+ */
+export const makePgIntegrationEventOutbox = Effect.gen(function* () {
+    const sql = yield* PgClient.PgClient;
+    const unavailable = portUnavailable(IntegrationEventOutboxUnavailableError);
+    const enqueue = (messages) => Effect.forEach(messages, (message) => sql `
+        INSERT INTO integration_event_outbox
+          (message_id, event_type, schema_version, occurred_at, payload)
+        VALUES
+          (${message.messageId}::text,
+           ${message.eventType}::text,
+           ${message.schemaVersion}::integer,
+           ${DateTime.toDate(message.occurredAt)}::timestamptz,
+           ${jsonbValue(sql, message.payload)})
+        ON CONFLICT (message_id) DO NOTHING
+      `, { discard: true }).pipe(Effect.catchTag('SqlError', unavailable('enqueue')));
+    const pending = (limit) => sql `
+      SELECT message_id     AS "messageId",
+             event_type     AS "eventType",
+             schema_version AS "schemaVersion",
+             occurred_at    AS "occurredAt",
+             payload
+      FROM integration_event_outbox
+      WHERE dispatched_at IS NULL
+      ORDER BY sequence_number ASC
+      LIMIT ${limit}::integer
+    `.pipe(Effect.map((rows) => rows.map(outboxMessageOf)), Effect.catchTag('SqlError', unavailable('pending')));
+    const markDispatched = (messageIds) => Effect.gen(function* () {
+        if (messageIds.length === 0)
+            return;
+        const dispatchedAt = yield* DateTime.now;
+        yield* sql `
+        UPDATE integration_event_outbox
+        SET dispatched_at = ${DateTime.toDate(dispatchedAt)}::timestamptz
+        WHERE message_id IN ${sql.in(messageIds)}
+          AND dispatched_at IS NULL
+      `;
+    }).pipe(Effect.catchTag('SqlError', unavailable('markDispatched')));
+    return {
+        enqueue,
+        pending,
+        markDispatched,
+    };
+});

package/dist/postgres/jsonb-value.d.ts

@@ -0,0 +1,10 @@
+import type { SqlClient } from '@effect/sql';
+import type { Fragment } from '@effect/sql/Statement';
+/**
+ * Hands a value to a `jsonb` column as JSON, whatever its shape. Write
+ * it wherever a query holds a JSON parameter, and the parameter travels
+ * as text the database casts, so an array stays an array instead of
+ * becoming the driver's own array literal. A value the encoder cannot
+ * write at all, `undefined` among them, lands as JSON null.
+ */
+export declare const jsonbValue: (sql: SqlClient.SqlClient, value: unknown) => Fragment;

package/dist/postgres/jsonb-value.js

@@ -0,0 +1,9 @@
+const jsonTextOf = (value) => JSON.stringify(value) ?? 'null';
+/**
+ * Hands a value to a `jsonb` column as JSON, whatever its shape. Write
+ * it wherever a query holds a JSON parameter, and the parameter travels
+ * as text the database casts, so an array stays an array instead of
+ * becoming the driver's own array literal. A value the encoder cannot
+ * write at all, `undefined` among them, lands as JSON null.
+ */
+export const jsonbValue = (sql, value) => sql `${jsonTextOf(value)}::jsonb`;

package/dist/postgres/layer.d.ts

@@ -0,0 +1,57 @@
+import type { FileSystem } from '@effect/platform';
+import type { PlatformError } from '@effect/platform/Error';
+import { SqlClient } from '@effect/sql';
+import type { SqlError } from '@effect/sql/SqlError';
+import { PgClient } from '@effect/sql-pg';
+import { DocumentNumberCounter, IntegrationEventOutbox, ProcessedEventRegistry, ReadinessProbe, TransactionBoundary } from '@satorio/machinery/ports';
+import { Layer } from 'effect';
+import type { ConfigError } from 'effect/ConfigError';
+/**
+ * The `@effect/sql-pg` client every other layer here builds on, opened
+ * from the environment `settings.ts` names.
+ */
+export declare const PostgresClientLive: Layer.Layer<PgClient.PgClient | SqlClient.SqlClient, ConfigError | PlatformError | SqlError, FileSystem.FileSystem>;
+/**
+ * The client the migration runner uses: one connection, under its own name.
+ *
+ * The same client for the migration runner: one connection, and its own name
+ * in `pg_stat_activity`, so a long migration is easy to spot next to the
+ * service's own pool.
+ */
+export declare const MigrationPgClientLive: Layer.Layer<PgClient.PgClient | SqlClient.SqlClient, ConfigError | PlatformError | SqlError, FileSystem.FileSystem>;
+/**
+ * The transaction boundary on a real Postgres transaction.
+ */
+export declare const PgTransactionBoundaryLive: Layer.Layer<TransactionBoundary, never, SqlClient.SqlClient>;
+/**
+ * The exactly-once claim on a real `processed_event` table.
+ */
+export declare const PgProcessedEventRegistryLive: Layer.Layer<ProcessedEventRegistry, never, PgClient.PgClient>;
+/**
+ * The document number counter on a real `document_number_counter` table.
+ */
+export declare const PgDocumentNumberCounterLive: Layer.Layer<DocumentNumberCounter, never, PgClient.PgClient>;
+/**
+ * The outbox on a real `integration_event_outbox` table.
+ */
+export declare const PgIntegrationEventOutboxLive: Layer.Layer<IntegrationEventOutbox, never, PgClient.PgClient>;
+/**
+ * The readiness probe on one `SELECT 1` against the service's own pool.
+ */
+export declare const PgReadinessProbeLive: Layer.Layer<ReadinessProbe, never, SqlClient.SqlClient>;
+/**
+ * The ports this mechanism implements, named together as one type. Your
+ * service adds its own stores alongside these in the composition root, on
+ * the same database client.
+ */
+export type PostgresPorts = ProcessedEventRegistry | IntegrationEventOutbox | DocumentNumberCounter | TransactionBoundary | ReadinessProbe;
+/**
+ * Every port this mechanism implements, on one client, for a service
+ * that supplies its own `FileSystem`.
+ */
+export declare const PostgresPortsLive: Layer.Layer<PostgresPorts | PgClient.PgClient | SqlClient.SqlClient, ConfigError | PlatformError | SqlError, FileSystem.FileSystem>;
+/**
+ * The same bundle on Bun's own file system, which is the whole Postgres
+ * side of the machinery in one layer.
+ */
+export declare const PostgresPortsOnBunLive: Layer.Layer<PostgresPorts | PgClient.PgClient | SqlClient.SqlClient, ConfigError | PlatformError | SqlError>;