@homeflare/alchemy 0.23.0 → 0.25.0

package/dist/postgres/database-attrs.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `Postgres.Database` props and attributes, and the one prop-level check that runs before any
+ * statement: the name's byte length against `NAMEDATALEN`.
+ *
+ * ⛔ EVERY ASSERTED PROP HERE HAS A CITED COLUMN. `docs/postgres.md#mapping` and
+ *   `database-provenance.test.ts` are what make that true rather than asserted: the test parses
+ *   the two committed fixtures (`create_database.sgml`'s synopsis, `pg_database.h`'s struct) and
+ *   fails if a prop here has no synopsis option or no catalog column behind it.
+ * ⛔ NO PASSWORD, EVER. A database has none in `pg_database` (S25) — `CREATE DATABASE` has no
+ *   password option at all (`gram.y@REL_18_6#createdb_opt_name`, measured: `IDENT | CONNECTION
+ *   LIMIT | ENCODING | LOCATION | OWNER | TABLESPACE | TEMPLATE`).
+ */
+/** NAMEDATALEN (`pg_config_manual.h@REL_18_6` line 29) minus the C string terminator: the
+ * longest name the server stores without truncating. */
+export declare const POSTGRES_NAME_MAX_BYTES = 63;
+/** UTF-8 byte length, the same unit `NAMEDATALEN` counts in (`scansup.c@REL_18_6#truncate_identifier`
+ * clips by `pg_mbcliplen`, a byte-oriented, multibyte-aware clip — never a JS `.length`, which
+ * counts UTF-16 code units and would pass a 63-byte multibyte name that is really 70+ bytes, or
+ * refuse a 63-byte name whose `.length` looks smaller). */
+export declare const utf8ByteLength: (value: string) => number;
+/**
+ * Declared, at-most-once-asserted properties of one database.
+ *
+ * Every prop here maps to a `CREATE DATABASE` `WITH` option `create_database.sgml` documents
+ * AND a `pg_database` column that stores it (`database-provenance.test.ts`). `TEMPLATE`,
+ * `STRATEGY` and `OID` are excluded because nothing in `pg_database` reads them back once the
+ * database exists; `ICU_RULES` and `COLLATION_VERSION` are excluded for having no consumer in
+ * this family today. See `docs/postgres.md#excluded`.
+ */
+export interface PostgresDatabaseProps {
+    /** At most 63 UTF-8 bytes — refused at plan past that (`PostgresDatabaseNameRefused`). The
+     * identity: a name change is a plan-time refusal, never a replace. */
+    readonly name: string;
+    /** A role name in `pg_roles`, asserted before create (`PostgresDatabaseOwnerMissing`) and
+     * compared against `pg_get_userbyid(datdba)` on every plan thereafter. */
+    readonly owner: string;
+    /** `pg_encoding_to_char(datdatabase.encoding)`, e.g. `"UTF8"`. @default the template's. */
+    readonly encoding?: string;
+    /** `'builtin' | 'icu' | 'libc'` — `pg_database.datlocprovider` decoded
+     * (`pg_collation.h@REL_18_6#collprovider_name`). @default the template's. */
+    readonly localeProvider?: 'builtin' | 'icu' | 'libc';
+    /** `pg_database.datcollate`. @default the template's. */
+    readonly lcCollate?: string;
+    /** `pg_database.datctype`. @default the template's. */
+    readonly lcCtype?: string;
+    /** `pg_database.datallowconn`. @default `true`. */
+    readonly allowConnections?: boolean;
+    /** `pg_database.datconnlimit`; `-1` means unlimited. @default `-1`. */
+    readonly connectionLimit?: number;
+    /** `pg_database.datistemplate`. @default `false`. */
+    readonly isTemplate?: boolean;
+    /** A tablespace name in `pg_tablespace`. @default the template's (usually `pg_default`). */
+    readonly tablespace?: string;
+}
+/** Live attributes, read back after every reconcile. No `password` — see the file header. */
+export interface PostgresDatabaseAttributes {
+    readonly name: string;
+    readonly oid: number;
+    readonly owner: string;
+    readonly encoding: string;
+    readonly localeProvider: 'builtin' | 'icu' | 'libc';
+    readonly collate: string;
+    readonly ctype: string;
+    readonly allowConnections: boolean;
+    readonly connectionLimit: number;
+    readonly isTemplate: boolean;
+    readonly tablespace: string;
+}
+/**
+ * Refuse a name the server would truncate, before any statement is built.
+ *
+ * ★ CALLED FROM `diff` (so a plan fails, never a deploy) AND FROM `reconcile` (so a fake or a
+ *   direct call gets the same refusal, never just a broken statement).
+ */
+export declare const nameByteRefusal: (name: string) => {
+    readonly byteLength: number;
+    readonly limit: number;
+} | undefined;
+//# sourceMappingURL=database-attrs.d.ts.map

package/dist/postgres/database-attrs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-attrs.d.ts","sourceRoot":"","sources":["../../src/postgres/database-attrs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;wDACwD;AACxD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C;;;2DAG2D;AAC3D,eAAO,MAAM,cAAc,UAAW,MAAM,KAAG,MAAoD,CAAC;AAEpG;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC;0EACsE;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;8EAC0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;iFAC6E;IAC7E,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;IACrD,yDAAyD;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,qDAAqD;IACrD,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,6FAA6F;AAC7F,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,SACpB,MAAM,KACX;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAK5D,CAAC"}

package/dist/postgres/database-sql.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The four statements `Postgres.Database` ever issues, and the quoting each one needs.
+ *
+ * ⛔ `CREATE DATABASE` TAKES NO BIND PARAMETERS FOR ANY OF ITS VALUES, INCLUDING `OWNER`.
+ *   Measured at `gram.y@REL_18_6`: `CreatedbStmt: CREATE DATABASE name opt_with
+ *   createdb_opt_list`, and every `createdb_opt_item` value is `NumericOnly`,
+ *   `opt_boolean_or_string` or the bare keyword `DEFAULT` — none of those productions reaches
+ *   `PARAM` (`$n`). `sql\`…\`` cannot help here; every free-form value in this statement is
+ *   escaped by hand, once, in this file, and the assembled text runs through `.unsafe()`.
+ * ⚠️ THE DATABASE NAME AND EFFECT'S OWN `sql(value)` IDENTIFIER HELPER DO NOT MIX. `name` is a
+ *   `ColId` (`gram.y@REL_18_6` line 17327), a single token — but `Statement.defaultEscape('"')`
+ *   (what `sql(value)` compiles to) also rewrites every `.` in the value to `"."`, because it is
+ *   built for a *qualified* name like `schema.table`. A database named `"my.app"` would come out
+ *   as `"my"."app"` — two tokens where `CreatedbStmt` parses exactly one — a syntax error the
+ *   engine would blame on this provider. `quoteIdent` below is the single-token form: it quotes
+ *   and doubles embedded `"`, and nothing else.
+ * ★ EVERY OTHER `WITH` VALUE (`OWNER`, `TABLESPACE`, `ENCODING`, `LOCALE_PROVIDER`,
+ *   `LC_COLLATE`, `LC_CTYPE`) IS A STRING LITERAL, NOT AN IDENTIFIER. Measured at the same tag:
+ *   `createdb_opt_item`'s string branch is `opt_boolean_or_string → NonReservedWord_or_Sconst →
+ *   NonReservedWord | Sconst`. A locale like `en_US.UTF-8` would hit the same dot-splitting
+ *   `quoteIdent` avoids if it were identifier-quoted; a plain `Sconst` (`quoteStringLiteral`) has
+ *   no such rule. This rests on `standard_conforming_strings = on` (the PG18 default, and
+ *   measured live 2026-09-23 — `docs/postgres.md#measured`); the escaper only ever doubles `'`
+ *   and never emits a backslash, so it never depends on which way that setting points.
+ */
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import * as Effect from 'effect/Effect';
+import type { PostgresDatabaseAttributes, PostgresDatabaseProps } from './database-attrs.ts';
+/** What every function in this file needs from a client — real (`PgClient.PgClient`) or fake
+ * (`fake-sql.ts`). Deliberately smaller than `SqlClient`: nothing here ever needs the tagged
+ * template, transactions or streaming, because every statement is either bound params through
+ * `.unsafe(text, params)` or a hand-escaped literal through `.unsafe(text)`. */
+export interface PgExecutor {
+    readonly unsafe: <A extends object>(sql: string, params?: ReadonlyArray<unknown>) => Effect.Effect<ReadonlyArray<A>, SqlError>;
+}
+/** Single-token identifier quoting: wrap in `"`, double any embedded `"`. No dot-splitting —
+ * see the file header. Used for the database name and, since a role or tablespace name is a
+ * `NonReservedWord` too, for `OWNER` and `TABLESPACE`. */
+export declare const quoteIdent: (value: string) => string;
+/** SQL string-literal quoting: wrap in `'`, double any embedded `'`. Used for every `WITH`
+ * value that is locale or encoding text, never for an identifier (see the file header). */
+export declare const quoteStringLiteral: (value: string) => string;
+/**
+ * Build the exact `CREATE DATABASE` text — a pure function, unit-tested on its own with no
+ * client at all. `CONNECTION LIMIT` and the two booleans are never string-escaped: an integer is
+ * `Math.trunc`ed and stringified, and a boolean is one of exactly two literal words this file
+ * writes, so no declared value reaches the statement through string interpolation unescaped.
+ */
+export declare const buildCreateDatabaseSql: (props: PostgresDatabaseProps) => string;
+/** `42P04` (`duplicate_database`) is a race: something else created the name between our read
+ * and our create. Measured at `internal/sqlError.ts@effect/sql-pg 4.0.0-rc.115`: every SQLSTATE
+ * starting `42` — this one included — classifies as `SqlSyntaxError`, the same tag a genuine
+ * syntax error would raise; there is no more specific tag to `catchTag` on. So this reads the
+ * raw code PostgreSQL sent, carried on `reason.cause.code` (`PgConnection.ts#errorFromFields`,
+ * `Object.assign(new Error(...), fields)`), rather than trusting the tag alone. */
+export declare const isDuplicateDatabaseRace: (error: SqlError) => boolean;
+/** `OWNER` is checked against `pg_roles` before any `CREATE`, so a missing role is
+ * `PostgresDatabaseOwnerMissing` at reconcile time rather than the server's own
+ * `ERROR: role "…" does not exist` surfacing as an unclassified statement failure. */
+export declare const roleExists: (pg: PgExecutor, role: string) => Effect.Effect<boolean, SqlError>;
+/** The read: one bound `SELECT` on `pg_database`, joined to the two functions that turn its raw
+ * owner and encoding columns into names (`docs/postgres.md#mapping`). `undefined` when the row
+ * is absent — ownership branding happens one layer up, in `database.ts`, not here. */
+export declare const selectDatabase: (pg: PgExecutor, name: string) => Effect.Effect<PostgresDatabaseAttributes | undefined, SqlError>;
+/** Compare every declared, asserted prop against the live row. Returns the name of the first
+ * prop that drifted, or `undefined` when every declared prop matches. `name` and `owner` are
+ * compared by their callers (identity and the create-time assertion), never here. */
+export declare const firstDrift: (props: PostgresDatabaseProps, live: PostgresDatabaseAttributes) => {
+    readonly prop: string;
+    readonly declared: unknown;
+    readonly live: unknown;
+} | undefined;
+//# sourceMappingURL=database-sql.d.ts.map

package/dist/postgres/database-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-sql.d.ts","sourceRoot":"","sources":["../../src/postgres/database-sql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE7F;;;gFAGgF;AAChF,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,EAChC,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,KAC5B,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;CAChD;AAED;;0DAE0D;AAC1D,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,MAA0C,CAAC;AAEtF;2FAC2F;AAC3F,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,MAA0C,CAAC;AAuB9F;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,UAAW,qBAAqB,KAAG,MACE,CAAC;AAEzE;;;;;mFAKmF;AACnF,eAAO,MAAM,uBAAuB,UAAW,QAAQ,KAAG,OAMzD,CAAC;AAIF;;sFAEsF;AACtF,eAAO,MAAM,UAAU,OAAQ,UAAU,QAAQ,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAItF,CAAC;AAwCJ;;sFAEsF;AACtF,eAAO,MAAM,cAAc,OACrB,UAAU,QACR,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,0BAA0B,GAAG,SAAS,EAAE,QAAQ,CACkC,CAAC;AAEpG;;qFAEqF;AACrF,eAAO,MAAM,UAAU,UACd,qBAAqB,QACtB,0BAA0B,KAC/B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,SAgBlF,CAAC"}

package/dist/postgres/database.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `Postgres.Database` — create-and-assert over a self-hosted PostgreSQL 18 cluster.
+ *
+ * ⛔ THIS IS NOT AN ALTER-CAPABLE RESOURCE. Every optional prop is asserted ONCE, at create, and
+ *   compared against the live row on every later plan; a mismatch is a typed
+ *   `PostgresDatabaseDrift` refusal, never an `ALTER DATABASE`. `docs/postgres.md` says why:
+ *   several of these props (`LC_COLLATE`, `LC_CTYPE`, `LOCALE_PROVIDER`) cannot be altered on a
+ *   live database at all without `ALTER … REFRESH COLLATION VERSION` semantics this family does
+ *   not implement, and the rest are left alone on principle rather than by accident.
+ * ⛔ `delete` NEVER DROPS. See `errors.ts#PostgresDatabaseDropRefused` and
+ *   `defaultRemovalPolicy: 'retain'` below — two independent reasons the engine never issues
+ *   `DROP DATABASE` through this provider.
+ * ★ A DATABASE CARRIES NO OWNERSHIP MARK (H1). `read` always answers `Unowned` for a match, the
+ *   same rule `Cloudflare.Snippets.Snippet` uses for a marker-less API — so every one of the
+ *   mini's 19 already-live databases needs `adopt(true)` in the stack that declares it.
+ */
+import { Resource } from 'alchemy';
+import type { Input } from 'alchemy/Input';
+import * as Provider from 'alchemy/Provider';
+import * as Effect from 'effect/Effect';
+import type { SqlError } from 'effect/unstable/sql/SqlError';
+import type { PostgresDatabaseAttributes, PostgresDatabaseProps } from './database-attrs.ts';
+import { type PostgresConnection } from './connection.ts';
+import type { PgExecutor } from './database-sql.ts';
+import { PostgresDatabaseCreateVanished, PostgresDatabaseDrift, PostgresDatabaseNameRefused, PostgresDatabaseOwnerMissing, PostgresDatabaseRenameRefused } from './errors.ts';
+export interface PostgresDatabase extends Resource<'Postgres.Database', PostgresDatabaseProps, PostgresDatabaseAttributes, never, PostgresConnection> {
+}
+export declare const PostgresDatabase: import("alchemy").ResourceClass<PostgresDatabase>;
+/** Mirrors `alchemy/Resource`'s own `isResourceOfType`: a resource constructor is a callable
+ * `Object.assign`ed function, not a plain object, so `typeof` must accept both — a bare
+ * `'object'` check (measured live in `scripts/smoke.ts`: it rejects `PostgresDatabase` itself,
+ * matching only an instance) is the regression this comment exists to prevent. */
+export declare const isPostgresDatabase: (value: unknown) => value is PostgresDatabase;
+/**
+ * The core of `reconcile`, against any {@link PgExecutor} — the real pooled client through
+ * `withPg`, or `fake-sql.ts`'s recording fake in tests. Kept apart from the provider wiring
+ * below so a lifecycle test drives this exact function, not a re-implementation of it.
+ */
+export declare const reconcileWithClient: (pg: PgExecutor, props: PostgresDatabaseProps) => Effect.Effect<PostgresDatabaseAttributes, PostgresDatabaseOwnerMissing | PostgresDatabaseDrift | PostgresDatabaseCreateVanished | SqlError>;
+/** The core of `read`: one bound `SELECT`, no ownership branding — the caller (the provider's
+ * `read` below, or a test) decides whether to wrap a match in `Unowned`. */
+export declare const readWithClient: (pg: PgExecutor, name: string) => Effect.Effect<PostgresDatabaseAttributes | undefined, SqlError, never>;
+/**
+ * The core of `diff`, entirely offline: `news` (declared) against `output` (last-applied
+ * attributes) — never a live query (that authoritative check is `reconcileWithClient`'s job, per
+ * S10). A rename is a plan-time refusal; over-long names are too, so a bad name never even reaches
+ * `reconcile`; every other change answers `update`, which `reconcileWithClient` then either
+ * applies (create) or refuses (drift on an already-live database).
+ */
+export declare const diffPostgresDatabase: (news: Input<PostgresDatabaseProps>, output: PostgresDatabaseAttributes | undefined) => Effect.Effect<{
+    readonly action: 'update';
+} | {
+    readonly action: 'noop';
+} | undefined, PostgresDatabaseNameRefused | PostgresDatabaseRenameRefused, never>;
+/**
+ * The five lifecycle handlers, wired to `withPg` for anything that touches a client. Exported
+ * on its own — not only through {@link PostgresDatabaseProvider}'s `Layer` — so a test can call
+ * `postgresDatabaseHandlers.delete(...)` directly, against the real implementation, without
+ * standing up the engine's provider machinery.
+ */
+export declare const postgresDatabaseHandlers: Provider.ProviderService<PostgresDatabase, PostgresConnection, never, never, PostgresConnection, never, never, never, never>;
+export declare const PostgresDatabaseProvider: () => import("effect/Layer").Layer<Provider.Provider<PostgresDatabase>, never, PostgresConnection>;
+//# sourceMappingURL=database.d.ts.map

package/dist/postgres/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/postgres/database.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAS7F,OAAO,EAAE,KAAK,kBAAkB,EAAU,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EAErB,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC9B,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,gBAAiB,SAAQ,QAAQ,CAChD,mBAAmB,EACnB,qBAAqB,EACrB,0BAA0B,EAC1B,KAAK,EACL,kBAAkB,CACnB;CAAG;AAEJ,eAAO,MAAM,gBAAgB,mDAE3B,CAAC;AAEH;;;kFAGkF;AAClF,eAAO,MAAM,kBAAkB,UAAW,OAAO,KAAG,KAAK,IAAI,gBAGD,CAAC;AAY7D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,OAC1B,UAAU,SACP,qBAAqB,KAC3B,MAAM,CAAC,MAAM,CACd,0BAA0B,EAC1B,4BAA4B,GAAG,qBAAqB,GAAG,8BAA8B,GAAG,QAAQ,CAqC9F,CAAC;AAEL;4EAC4E;AAC5E,eAAO,MAAM,cAAc,OAAQ,UAAU,QAAQ,MAAM,2EAA6B,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,SACzB,KAAK,CAAC,qBAAqB,CAAC,UAC1B,0BAA0B,GAAG,SAAS;qBAgBhB,QAAQ;;qBAA0B,MAAM;kFACpE,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,8HA4BnC,CAAC;AAEH,eAAO,MAAM,wBAAwB,oGACyB,CAAC"}

package/dist/postgres/errors.d.ts

@@ -0,0 +1,86 @@
+declare const PostgresDatabaseNameRefused_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: "PostgresDatabaseNameRefused";
+} & Readonly<A>;
+/**
+ * A declared name would be silently truncated by the server (`NAMEDATALEN` 64, so 63 UTF-8
+ * bytes is the last one that survives whole) — refused at plan, before any statement runs.
+ *
+ * ⛔ WHY THIS IS A PLAN-TIME REFUSAL AND NOT A SERVER ERROR. `truncate_identifier`
+ *   (`scansup.c@REL_18_6` line 93) clips a long name to 63 bytes and raises only a `NOTICE`
+ *   (`errcode(ERRCODE_NAME_TOO_LONG)`), never an error. A create would succeed against the
+ *   TRUNCATED name, so the next plan's read (`WHERE datname = $1`, the name exactly as
+ *   declared) would find nothing and try to create it again — forever. See
+ *   `doc/postgres.md#name`.
+ */
+export declare class PostgresDatabaseNameRefused extends PostgresDatabaseNameRefused_base<{
+    readonly name: string;
+    readonly byteLength: number;
+    readonly limit: number;
+}> {
+    get message(): string;
+}
+declare const PostgresDatabaseRenameRefused_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: "PostgresDatabaseRenameRefused";
+} & Readonly<A>;
+/** A logical id's `name` changed. A database's name is its identity; there is no `ALTER … RENAME`
+ * in this family's vocabulary (see `docs/postgres.md`), and `diff` never turns this into a
+ * `replace` — a replace here is `DROP DATABASE` before `CREATE DATABASE`, on data. */
+export declare class PostgresDatabaseRenameRefused extends PostgresDatabaseRenameRefused_base<{
+    readonly from: string;
+    readonly to: string;
+}> {
+    get message(): string;
+}
+declare const PostgresDatabaseOwnerMissing_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: "PostgresDatabaseOwnerMissing";
+} & Readonly<A>;
+/** `OWNER` names a role `pg_roles` does not have, checked before the `CREATE DATABASE` that
+ * would otherwise fail on it. Postgres itself refuses the same case with `ERROR:  role "…" does
+ * not exist` (`createdb()`, `dbcommands.c`) — this tag exists so the refusal is typed and the
+ * check runs before any statement, not caught from the driver's text. */
+export declare class PostgresDatabaseOwnerMissing extends PostgresDatabaseOwnerMissing_base<{
+    readonly database: string;
+    readonly owner: string;
+}> {
+    get message(): string;
+}
+declare const PostgresDatabaseDrift_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: "PostgresDatabaseDrift";
+} & Readonly<A>;
+/** A live, asserted property no longer matches the declaration. `reconcile` never issues an
+ * `ALTER DATABASE` to fix this — see `docs/postgres.md` for why each asserted prop stops at
+ * create. */
+export declare class PostgresDatabaseDrift extends PostgresDatabaseDrift_base<{
+    readonly database: string;
+    readonly prop: string;
+    readonly declared: unknown;
+    readonly live: unknown;
+}> {
+    get message(): string;
+}
+declare const PostgresDatabaseDropRefused_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: "PostgresDatabaseDropRefused";
+} & Readonly<A>;
+/** `delete` never drops a database. `DROP DATABASE` is destructive and irreversible on data
+ * this family did not create from nothing (most declared databases here are adopted, not
+ * created); the decision to remove one stays a human act on the host. */
+export declare class PostgresDatabaseDropRefused extends PostgresDatabaseDropRefused_base<{
+    readonly database: string;
+}> {
+    get message(): string;
+}
+declare const PostgresDatabaseCreateVanished_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: "PostgresDatabaseCreateVanished";
+} & Readonly<A>;
+/** `CREATE DATABASE` raised no error, but the immediate re-read (S10: never trust the write's
+ * own report) still finds nothing. Measured to have no real trigger in a correctly speaking
+ * client, but S20 forbids `Effect.die` here regardless — an invariant violation is a typed
+ * failure the caller can see and retry, never a defect that crashes the whole engine. */
+export declare class PostgresDatabaseCreateVanished extends PostgresDatabaseCreateVanished_base<{
+    readonly database: string;
+}> {
+    get message(): string;
+}
+export type PostgresDatabaseError = PostgresDatabaseNameRefused | PostgresDatabaseRenameRefused | PostgresDatabaseOwnerMissing | PostgresDatabaseDrift | PostgresDatabaseDropRefused | PostgresDatabaseCreateVanished;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/postgres/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/postgres/errors.ts"],"names":[],"mappings":";;;AAcA;;;;;;;;;;GAUG;AACH,qBAAa,2BAA4B,SAAQ,iCAAgD;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;;;;AAED;;sFAEsF;AACtF,qBAAa,6BAA8B,SAAQ,mCAEjD;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;;;;AAED;;;yEAGyE;AACzE,qBAAa,4BAA6B,SAAQ,kCAAiD;IACjG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;aAEa;AACb,qBAAa,qBAAsB,SAAQ,2BAA0C;IACnF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAO7B;CACF;;;;AAED;;yEAEyE;AACzE,qBAAa,2BAA4B,SAAQ,iCAAgD;IAC/F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;;;;AAED;;;yFAGyF;AACzF,qBAAa,8BAA+B,SAAQ,oCAElD;IACA,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAM7B;CACF;AAED,MAAM,MAAM,qBAAqB,GAC7B,2BAA2B,GAC3B,6BAA6B,GAC7B,4BAA4B,GAC5B,qBAAqB,GACrB,2BAA2B,GAC3B,8BAA8B,CAAC"}

package/dist/postgres/fake-sql.d.ts

@@ -0,0 +1,22 @@
+import type { PostgresDatabaseAttributes } from './database-attrs.ts';
+import type { PgExecutor } from './database-sql.ts';
+export interface RecordedStatement {
+    readonly text: string;
+    readonly params: ReadonlyArray<unknown>;
+}
+export interface FakeSql extends PgExecutor {
+    readonly statements: ReadonlyArray<RecordedStatement>;
+    /** Mutable on purpose: a test seeds a row a "competing" statement would have produced (the
+     * `42P04` race case) before the fake ever sees it. */
+    readonly databases: Map<string, PostgresDatabaseAttributes>;
+}
+export interface FakeSqlOptions {
+    readonly roles?: ReadonlyArray<string>;
+    readonly databases?: ReadonlyArray<PostgresDatabaseAttributes>;
+    /** Fail the NEXT `CREATE DATABASE` with SQLSTATE `42P04` (duplicate_database), once, the way a
+     * concurrent creator racing this reconcile would — classified exactly as
+     * `@effect/sql-pg`'s own driver classifies it (`database-sql.ts`'s header). */
+    readonly raceNextCreate?: boolean;
+}
+export declare const makeFakeSql: (options?: FakeSqlOptions) => FakeSql;
+//# sourceMappingURL=fake-sql.d.ts.map

package/dist/postgres/fake-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-sql.d.ts","sourceRoot":"","sources":["../../src/postgres/fake-sql.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,OAAQ,SAAQ,UAAU;IACzC,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACtD;0DACsD;IACtD,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;IAC/D;;mFAE+E;IAC/E,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC;AAoCD,eAAO,MAAM,WAAW,aAAa,cAAc,KAAQ,OAkD1D,CAAC"}

package/dist/postgres/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * PostgreSQL providers for Alchemy — `Postgres.Database`, create-and-assert over a self-hosted
+ * cluster, walked against PostgreSQL 18.6. See `docs/postgres.md`.
+ *
+ * ⛔ THIS BARREL IS THE PUBLIC API, deliberately smaller than the directory: `fake-sql.ts` is a
+ *   test double, not something a consuming stack should import.
+ */
+export type { PostgresConnectionConfig } from './connection.ts';
+export { PostgresConnection, postgresConnection, withPg } from './connection.ts';
+export type { PostgresDatabaseAttributes, PostgresDatabaseProps } from './database-attrs.ts';
+export { POSTGRES_NAME_MAX_BYTES, nameByteRefusal, utf8ByteLength } from './database-attrs.ts';
+export { buildCreateDatabaseSql, firstDrift, isDuplicateDatabaseRace, quoteIdent, quoteStringLiteral, roleExists, selectDatabase, } from './database-sql.ts';
+export { PostgresDatabase, PostgresDatabaseProvider, isPostgresDatabase } from './database.ts';
+export { PostgresDatabaseDrift, PostgresDatabaseDropRefused, PostgresDatabaseNameRefused, PostgresDatabaseOwnerMissing, PostgresDatabaseRenameRefused, type PostgresDatabaseError, } from './errors.ts';
+export { postgresProviders } from './providers.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/postgres/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/postgres/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,YAAY,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACjF,YAAY,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC/F,OAAO,EACL,sBAAsB,EACtB,UAAU,EACV,uBAAuB,EACvB,UAAU,EACV,kBAAkB,EAClB,UAAU,EACV,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC/F,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/postgres/index.js

@@ -0,0 +1,238 @@
+// src/postgres/connection.ts
+import * as PgClient from "@effect/sql-pg/PgClient";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+class PostgresConnection extends Context.Service()("Postgres.Connection") {
+}
+var postgresConnection = (config) => Layer.succeed(PostgresConnection, Effect.succeed(config));
+var withPg = (build) => Effect.gen(function* () {
+  const resolveConfig = yield* PostgresConnection;
+  const config = yield* resolveConfig;
+  return yield* Effect.provide(Effect.flatMap(PgClient.PgClient, build), PgClient.layer(config));
+});
+// src/postgres/database-attrs.ts
+var POSTGRES_NAME_MAX_BYTES = 63;
+var utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
+var nameByteRefusal = (name) => {
+  const byteLength = utf8ByteLength(name);
+  return byteLength > POSTGRES_NAME_MAX_BYTES ? { byteLength, limit: POSTGRES_NAME_MAX_BYTES } : undefined;
+};
+// src/postgres/database-sql.ts
+import * as Effect2 from "effect/Effect";
+var quoteIdent = (value) => `"${value.replace(/"/g, '""')}"`;
+var quoteStringLiteral = (value) => `'${value.replace(/'/g, "''")}'`;
+var withOptions = (props) => {
+  const parts = [`OWNER ${quoteIdent(props.owner)}`];
+  if (props.encoding !== undefined)
+    parts.push(`ENCODING ${quoteStringLiteral(props.encoding)}`);
+  if (props.localeProvider !== undefined) {
+    parts.push(`LOCALE_PROVIDER ${quoteStringLiteral(props.localeProvider)}`);
+  }
+  if (props.lcCollate !== undefined)
+    parts.push(`LC_COLLATE ${quoteStringLiteral(props.lcCollate)}`);
+  if (props.lcCtype !== undefined)
+    parts.push(`LC_CTYPE ${quoteStringLiteral(props.lcCtype)}`);
+  if (props.tablespace !== undefined)
+    parts.push(`TABLESPACE ${quoteIdent(props.tablespace)}`);
+  if (props.allowConnections !== undefined) {
+    parts.push(`ALLOW_CONNECTIONS ${props.allowConnections ? "true" : "false"}`);
+  }
+  if (props.connectionLimit !== undefined) {
+    parts.push(`CONNECTION LIMIT ${String(Math.trunc(props.connectionLimit))}`);
+  }
+  if (props.isTemplate !== undefined)
+    parts.push(`IS_TEMPLATE ${props.isTemplate ? "true" : "false"}`);
+  return parts.join(" ");
+};
+var buildCreateDatabaseSql = (props) => `CREATE DATABASE ${quoteIdent(props.name)} WITH ${withOptions(props)}`;
+var isDuplicateDatabaseRace = (error) => {
+  if (error.reason._tag !== "SqlSyntaxError")
+    return false;
+  const cause = error.reason.cause;
+  return typeof cause === "object" && cause !== null && cause.code === "42P04";
+};
+var ROLE_EXISTS_SQL = "SELECT 1 AS present FROM pg_roles WHERE rolname = $1";
+var roleExists = (pg, role) => Effect2.map(pg.unsafe(ROLE_EXISTS_SQL, [role]), (rows) => rows.length > 0);
+var SELECT_DATABASE_SQL = `SELECT
+    d.oid AS oid,
+    d.datname AS name,
+    pg_get_userbyid(d.datdba) AS owner,
+    pg_encoding_to_char(d.encoding) AS encoding,
+    CASE d.datlocprovider
+      WHEN 'b' THEN 'builtin' WHEN 'i' THEN 'icu' WHEN 'c' THEN 'libc'
+      ELSE 'libc'
+    END AS "localeProvider",
+    d.datcollate AS collate,
+    d.datctype AS ctype,
+    d.datallowconn AS "allowConnections",
+    d.datconnlimit AS "connectionLimit",
+    d.datistemplate AS "isTemplate",
+    t.spcname AS tablespace
+  FROM pg_database d
+  JOIN pg_tablespace t ON t.oid = d.dattablespace
+  WHERE d.datname = $1`;
+var selectDatabase = (pg, name) => Effect2.map(pg.unsafe(SELECT_DATABASE_SQL, [name]), (rows) => rows[0]);
+var firstDrift = (props, live) => {
+  const checks = [
+    ["encoding", props.encoding, live.encoding],
+    ["localeProvider", props.localeProvider, live.localeProvider],
+    ["lcCollate", props.lcCollate, live.collate],
+    ["lcCtype", props.lcCtype, live.ctype],
+    ["allowConnections", props.allowConnections, live.allowConnections],
+    ["connectionLimit", props.connectionLimit, live.connectionLimit],
+    ["isTemplate", props.isTemplate, live.isTemplate],
+    ["tablespace", props.tablespace, live.tablespace]
+  ];
+  for (const [prop, declared, liveValue] of checks) {
+    if (declared !== undefined && declared !== liveValue)
+      return { prop, declared, live: liveValue };
+  }
+  return;
+};
+// src/postgres/database.ts
+import { Resource } from "alchemy";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import * as Effect3 from "effect/Effect";
+
+// src/postgres/errors.ts
+import * as Data from "effect/Data";
+
+class PostgresDatabaseNameRefused extends Data.TaggedError("PostgresDatabaseNameRefused") {
+  get message() {
+    return `Postgres.Database "${this.name}": ${String(this.byteLength)} UTF-8 bytes, over the ` + `${String(this.limit)}-byte limit (NAMEDATALEN 64, minus the terminator). PostgreSQL would ` + "accept the CREATE and silently truncate the name with only a NOTICE, so this plan refuses " + "it instead of creating a database no later read will ever find again.";
+  }
+}
+
+class PostgresDatabaseRenameRefused extends Data.TaggedError("PostgresDatabaseRenameRefused") {
+  get message() {
+    return `Postgres.Database: the declared name changed from "${this.from}" to "${this.to}". A ` + "rename is refused at plan — this provider never replaces a database (that is DROP then " + "CREATE) and never runs ALTER … RENAME. Declare a new logical id for the new name, and " + "remove the old one once its data has moved.";
+  }
+}
+
+class PostgresDatabaseOwnerMissing extends Data.TaggedError("PostgresDatabaseOwnerMissing") {
+  get message() {
+    return `Postgres.Database "${this.database}": OWNER "${this.owner}" is not a role in pg_roles.`;
+  }
+}
+
+class PostgresDatabaseDrift extends Data.TaggedError("PostgresDatabaseDrift") {
+  get message() {
+    return `Postgres.Database "${this.database}": ${this.prop} is declared as ` + `${JSON.stringify(this.declared)} but the live database has ${JSON.stringify(this.live)}. ` + "This provider never issues ALTER DATABASE — update the declaration to match the live " + "value, or change it by hand and re-plan.";
+  }
+}
+
+class PostgresDatabaseDropRefused extends Data.TaggedError("PostgresDatabaseDropRefused") {
+  get message() {
+    return `Postgres.Database "${this.database}": delete is refused. This provider never issues DROP ` + "DATABASE. Drop it by hand over the trust socket if you mean to remove it, then remove the " + "declaration.";
+  }
+}
+
+class PostgresDatabaseCreateVanished extends Data.TaggedError("PostgresDatabaseCreateVanished") {
+  get message() {
+    return `Postgres.Database "${this.database}": CREATE DATABASE raised no error, but the database ` + "is still absent on the immediate re-read. Re-plan — this is not a state this provider " + "expects to reach.";
+  }
+}
+
+// src/postgres/database.ts
+var PostgresDatabase = Resource("Postgres.Database", {
+  defaultRemovalPolicy: "retain"
+});
+var isPostgresDatabase = (value) => (typeof value === "object" || typeof value === "function") && value !== null && value.Type === "Postgres.Database";
+var liveDrift = (props, live) => {
+  if (props.owner !== live.owner) {
+    return { prop: "owner", declared: props.owner, live: live.owner };
+  }
+  return firstDrift(props, live);
+};
+var reconcileWithClient = (pg, props) => Effect3.gen(function* () {
+  const observed = yield* selectDatabase(pg, props.name);
+  if (observed === undefined) {
+    const ownerPresent = yield* roleExists(pg, props.owner);
+    if (!ownerPresent) {
+      return yield* Effect3.fail(new PostgresDatabaseOwnerMissing({ database: props.name, owner: props.owner }));
+    }
+    yield* pg.unsafe(buildCreateDatabaseSql(props)).pipe(Effect3.asVoid, Effect3.catchTag("SqlError", (error) => isDuplicateDatabaseRace(error) ? Effect3.succeed(undefined) : Effect3.fail(error)));
+    const created = yield* selectDatabase(pg, props.name);
+    if (created === undefined) {
+      return yield* Effect3.fail(new PostgresDatabaseCreateVanished({ database: props.name }));
+    }
+    return created;
+  }
+  const drift = liveDrift(props, observed);
+  if (drift !== undefined) {
+    return yield* Effect3.fail(new PostgresDatabaseDrift({
+      database: props.name,
+      prop: drift.prop,
+      declared: drift.declared,
+      live: drift.live
+    }));
+  }
+  return observed;
+});
+var readWithClient = (pg, name) => selectDatabase(pg, name);
+var diffPostgresDatabase = (news, output) => Effect3.gen(function* () {
+  if (output === undefined || !isResolved(news))
+    return;
+  if (news.name !== output.name) {
+    return yield* Effect3.fail(new PostgresDatabaseRenameRefused({ from: output.name, to: news.name }));
+  }
+  const nameRefusal = nameByteRefusal(news.name);
+  if (nameRefusal !== undefined) {
+    return yield* Effect3.fail(new PostgresDatabaseNameRefused({ name: news.name, ...nameRefusal }));
+  }
+  const changed = news.owner !== output.owner || firstDrift(news, output) !== undefined;
+  return changed ? { action: "update" } : { action: "noop" };
+});
+var postgresDatabaseHandlers = PostgresDatabase.Provider.of({
+  list: () => Effect3.succeed([]),
+  nuke: { skip: true },
+  read: ({ olds, output }) => Effect3.gen(function* () {
+    const name = output?.name ?? olds.name;
+    const live = yield* withPg((pg) => readWithClient(pg, name));
+    return live === undefined ? undefined : Unowned(live);
+  }),
+  diff: ({ news, output }) => diffPostgresDatabase(news, output),
+  reconcile: ({ news }) => Effect3.gen(function* () {
+    const nameRefusal = nameByteRefusal(news.name);
+    if (nameRefusal !== undefined) {
+      return yield* Effect3.fail(new PostgresDatabaseNameRefused({ name: news.name, ...nameRefusal }));
+    }
+    return yield* withPg((pg) => reconcileWithClient(pg, news));
+  }),
+  delete: ({ olds }) => Effect3.fail(new PostgresDatabaseDropRefused({ database: olds.name }))
+});
+var PostgresDatabaseProvider = () => Provider.succeed(PostgresDatabase, postgresDatabaseHandlers);
+// src/postgres/providers.ts
+import * as Layer2 from "effect/Layer";
+var postgresProviders = (config) => PostgresDatabaseProvider().pipe(Layer2.provide(postgresConnection(config)));
+export {
+  POSTGRES_NAME_MAX_BYTES,
+  PostgresConnection,
+  PostgresDatabase,
+  PostgresDatabaseDrift,
+  PostgresDatabaseDropRefused,
+  PostgresDatabaseNameRefused,
+  PostgresDatabaseOwnerMissing,
+  PostgresDatabaseProvider,
+  PostgresDatabaseRenameRefused,
+  buildCreateDatabaseSql,
+  firstDrift,
+  isDuplicateDatabaseRace,
+  isPostgresDatabase,
+  nameByteRefusal,
+  postgresConnection,
+  postgresProviders,
+  quoteIdent,
+  quoteStringLiteral,
+  roleExists,
+  selectDatabase,
+  utf8ByteLength,
+  withPg
+};
+
+//# debugId=84B82CBA6D8F3F5F64756E2164756E21
+//# sourceMappingURL=index.js.map