@dbsp/adapter-pgsql 4.0.0 → 6.0.0

package/dist/index.d.ts

@@ -1,97 +1,14 @@
+import { N as NamingPlugin, F as FkColumnDerivation, C as ChangeKind, G as GeneratedPostconditionSession, T as TransitionJournalQueryable, P as PgLockedRun, a as PgOutcomeCheckpointObserver, b as ConvergePgOptions$1, c as PgPhysicalModel, d as PgConvergeResult, e as PgConvergeCheckResult, f as PgLedgerScopeCurrency, r as readTransitionJournal } from './outcome-protocol-Dw5DYhnA.js';
+export { A as AddedEnumValue, g as AutoIncrementTransitionUnsupportedError, h as CamelCaseNamingPlugin, i as CanonicalizeCheckConstraintsOptions, j as CheckConstraintCanonicalizationError, k as CheckConstraintCanonicalizationWarning, l as CheckConstraintNewEnumValueError, m as ColumnDefaultCanonicalizationError, n as ColumnDefaultCanonicalizationWarning, o as ComparePgsqlDatabaseSchemaOptions, p as CompareSchemataOptions, D as DEFAULT_PK_COLUMN, q as DetectedHierarchy, s as DiffSummary, E as ExpressionCanonicalizationUnavailableError, t as ExpressionCanonicalizationWarning, u as ExpressionKeyedIndexPredicateCanonicalizationUnsupportedError, v as GenerateDDLOptions, w as GeneratedPostcondition, x as GeneratedPostconditionBindingAddress, y as GeneratedPostconditionBindingResolutionError, z as GeneratedPostconditionProofInFlightError, B as GeneratedPostconditionReplanRequiredError, H as GeneratedPostconditionSessionDeactivatedError, I as GeneratedPostconditionWorkInFlightError, J as IdentityNamingPlugin, K as IndexCapabilityContext, L as IndexFeatureUnsupportedError, M as IndexPredicateCanonicalizationError, O as IndexRenderSpec, Q as IntrospectedModelIR, R as IntrospectionOptions, S as MigrationSQLOptions, U as NonConvergentSchemaDiffError, V as NonConvergentSchemaDiffSurface, W as PG_LEDGER_SHAPE_VERSION, X as PartialIndexPredicateNewEnumValueError, Y as PgAdmittedOperation, Z as PgAdmittedOperationResult, _ as PgAdvisoryLockKey, $ as PgAdvisoryLockResult, a0 as PgApplicationStepOwnedState, a1 as PgApplicationStepTx, a2 as PgCatalogueIdentityQueryable, a3 as PgConvergeApplicationStep, a4 as PgConvergeAssertStep, a5 as PgConvergeInitializationFailure, a6 as PgConvergeOnceStep, a7 as PgConvergePlannedStep, a8 as PgConvergeRefusal, a9 as PgConvergeRefusalChange, aa as PgConvergeRefusalError, ab as PgLedgerLockResult, ac as PgLedgerStorageUnsupportedError, ad as PgLedgerTarget, ae as PgOutcomeCheckpoint, af as PgOutcomeClaimRequest, ag as PgOutcomeExecutionRequest, ah as PgOutcomeNonTransactionalRequest, ai as PgOutcomeReadBackFactory, aj as PgOutcomeRecoveryRequest, ak as PgOutcomeRecoveryResult, al as PgOutcomeResolution, am as PgOutcomeResolutionAppendResult, an as PgOutcomeResult, ao as PgOutcomeTransactionalRequest, ap as PgOwnedCheckState, aq as PgPhysicalModelInput, ar as PgPhysicalModelInputError, as as PgPhysicalNameClaim, at as PgPhysicalNameCollision, au as PgPhysicalNameCollisionError, av as PgPhysicalNamespace, aw as PgReinitializePreflightOptions, ax as PgReinitializePreflightPool, ay as PgSchemaDiff, az as PgsqlAdapter, aA as PgsqlAdapterOptions, aB as PgsqlAdvisoryLockOptionsError, aC as PgsqlBorrowedClientAdapterOptions, aD as PgsqlCompileOnlyAdapterOptions, aE as PgsqlPinnedConnectionAbortSignalError, aF as PgsqlPoolAdapterOptions, aG as PgsqlPreparedStatementReplayError, aH as PgsqlPreparedStatementsOptions, aI as PgsqlRawSqlTransactionControlError, aJ as PgsqlTransactionAbortSignalError, aK as PgsqlTransactionAbortedCommitError, aL as PgsqlTransactionAbortedError, aM as PgsqlTransactionOptionsError, aN as PgsqlTransactionTimeoutError, aO as RawIndexPredicateFallbackError, aP as ReferencedKeyKind, aQ as ReferencedKeyRemovalConflict, aR as ReferencedKeyRemovalError, aS as RollbackOnlyPgsqlScope, aT as SchemaChange, aU as SchemaDiff, aV as SchemaScopeOptions, aW as TransitionRunIdentityMismatchError, aX as acquirePgLedgerLocks, aY as appendIntentJournal, aZ as appendTransitionAuthorization, a_ as assertCreateIndexSupported, a$ as assertCreateIndexesSupported, b0 as assertDeclarableChangeKind, b1 as assertGeneratedPostconditionSession, b2 as assertNoRepeatedExpressionSurfaceDrift, b3 as camelCaseNaming, b4 as canGenerateCreateIndex, b5 as canonicalizeCheckConstraints, b6 as comparePgsqlDatabaseSchema, b7 as compareSchemata, b8 as createPgPhysicalModel, b9 as createPgTransitionRunPersister, ba as createPgsqlAdapter, bb as createPgsqlCompileOnlyAdapter, bc as createPgsqlGeneratedManagedStep, bd as decodeGeneratedPostcondition, be as decodeGeneratedPostconditionPayload, bf as defaultFkDerivation, bg as ensureDbspMetaLedger, bh as ensurePgLedger, bi as ensurePgLedgerStorageVersion, bj as ensureTransitionJournal, bk as executePgAdmittedOperation, bl as generateCreateIndex, bm as generateDDL, bn as generateDownSQL, bo as generateMigrationSQL, bp as generatedPostconditionDigest, bq as generatedPostconditionForChange, br as getNamingPluginForDbCasing, bs as identityNaming, bt as introspect, bu as readPgCatalogueIdentity, bv as readPgLedgerMarker, bw as readPgLedgerReservationsForExecution, bx as readPgLedgerScopeCurrency, by as readPgOutcomeRecoveryReadBack, bz as readVerifiedPgLedgerReservationsForPair, bA as recordPgLedgerIdentity, bB as renderCreateDbspMetaSchemaSql, bC as renderCreateIndex, bD as renderCreateLedgerEventTableSql, bE as renderCreateLedgerIdentityTableSql, bF as renderCreateLedgerImmutabilityFunctionSql, bG as renderCreateLedgerImmutabilityTriggerSql, bH as renderCreateLedgerMarkerTableSql, bI as renderCreateLedgerReservationTableSql, bJ as renderCreateLedgerTerminalMemberIndexSql, bK as renderCreateTransitionAuthorizationTableSql, bL as renderCreateTransitionJournalTableSql, bM as renderCreateTransitionRunPlanTableSql, bN as renderCreateTransitionRunTableSql, bO as runPgReinitializePreflight, bP as toGeneratedPostconditionBindingAddress, bQ as validatePgLedgerRuntimeIntegrity, bR as verifyGeneratedCheckPostcondition, bS as verifyGeneratedColumnPostcondition, bT as verifyGeneratedIdentityPostcondition, bU as verifyGeneratedIndexPostcondition, bV as verifyGeneratedTablePostcondition, bW as withGeneratedPostconditionSession } from './outcome-protocol-Dw5DYhnA.js';
 import * as _dbsp_core from '@dbsp/core';
-import { IndexInfo, TruncateOptions, VacuumOptions, AlterColumnOptions, CreateIndexOptions, DropIndexOptions, ExpressionRef, ModelIR as ModelIR$1, ValidatedManagedStepManifest, ExecutionCoordinator, CapabilityDescriptor } from '@dbsp/core';
+import { ExpressionRef, ModelIR as ModelIR$1, ValidatedManagedStepManifest, ExecutionCoordinator, CapabilityDescriptor } from '@dbsp/core';
 export { normalizeSQL } from '@dbsp/core';
 import * as _dbsp_types from '@dbsp/types';
-import { DialectCapabilities, ModelIR, ColumnListInput, ParamIntent, JsonAggOrderByEntry, IndexIR, HierarchyIR, Adapter, DbCasing, AdapterLogger, AdapterCapabilities, ConnectionAvailability, PlanReport, CompiledNqlQuery, CompileOptions, CompiledQuery, CompileResultWithIncludes, SubqueryIncludeInfo, ExpressionIntent, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, RecursivePlanReport, CteQueryIntent, SetOperationIntent, DumpMeta, Dump, AdapterStreamOptions, PinnedConnectionOptions, TransactionOptions, ColumnIR, MutationReturningItem, WhereIntent, OutputDescriptor, QueryIntent, LedgerHome, LedgerAddress, LedgerPayload, ScopedApprovalSet, NormalizedManagedStep, LedgerChainMember, OperationKindRef, SemanticArtifactRef, ProvenPlanShape, PostgreSqlObservationTargetIdentity, ExecutionContract, TransitionSessionClient, TransitionLessor, ExclusiveTransitionTarget, ObservationIssuer, ObservationRequest, ObservationContext, EvidenceObservation, TypeRef, ExpressionValue, CollationRef, LogicalIdentity, PhysicalOperation, OperationEffectAssessment, FingerprintManifest, DurableIntentRecord, IssuedObservation, ApplyGuard, AdvisoryObservation, TransactionalCompletionRecord, StepJournal, UnsafeNativeFragment, ResourceAddress, ExecutableAssertion, Assumption, TransitionRule, TransitionCompositionFact, TrustRoot, RequiredEnumLabelIR, TableReaddressDeclaration, LedgerReservationRow, LedgerRefusal, ContainmentClosureDestructiveOutcome, LedgerClaimKind } from '@dbsp/types';
+import { OutputDescriptor, PlanReport, DialectCapabilities, ModelIR, ColumnListInput, ParamIntent, JsonAggOrderByEntry, LedgerPayload, LedgerAddress, NormalizedManagedStep, ColumnIR, MutationReturningItem, WhereIntent, DbCasing, QueryIntent, CompiledQuery, SetOperationIntent, CompileOptions, LedgerHome, ScopedApprovalSet, LedgerChainMember, OperationKindRef, SemanticArtifactRef, ProvenPlanShape, PostgreSqlObservationTargetIdentity, ExecutionContract, TransitionSessionClient, TransitionLessor, ExclusiveTransitionTarget, ObservationIssuer, ObservationRequest, ObservationContext, EvidenceObservation, TypeRef, ExpressionValue, CollationRef, LogicalIdentity, PhysicalOperation, OperationEffectAssessment, FingerprintManifest, DurableIntentRecord, IssuedObservation, ApplyGuard, AdvisoryObservation, TransactionalCompletionRecord, StepJournal, UnsafeNativeFragment, ResourceAddress, ExecutableAssertion, Assumption, TransitionRule, TransitionCompositionFact, TrustRoot, RequiredEnumLabelIR, TableReaddressDeclaration, LedgerReservationRow, LedgerRefusal, ContainmentClosureDestructiveOutcome, LedgerClaimKind } from '@dbsp/types';
 import * as _pgsql_types from '@pgsql/types';
 import { Node, OnConflictClause, ParamRef } from '@pgsql/types';
-import { C as ChangeKind, a as CompareSchemataOptions, S as SchemaDiff, T as TransitionJournalQueryable, P as PgLockedRun, b as PgOutcomeCheckpointObserver } from './outcome-protocol-CACJDzli.js';
-export { D as DiffSummary, E as ExpressionCanonicalizationUnavailableError, G as GeneratedPostcondition, c as GeneratedPostconditionBindingAddress, d as GeneratedPostconditionBindingResolutionError, e as GeneratedPostconditionProofInFlightError, f as GeneratedPostconditionReplanRequiredError, g as GeneratedPostconditionSession, h as GeneratedPostconditionSessionDeactivatedError, i as GeneratedPostconditionWorkInFlightError, j as PG_LEDGER_SHAPE_VERSION, k as PgAdmittedOperation, l as PgAdmittedOperationResult, m as PgCatalogueIdentityQueryable, n as PgLedgerLockResult, o as PgLedgerScopeCurrency, p as PgLedgerStorageUnsupportedError, q as PgLedgerTarget, r as PgOutcomeCheckpoint, s as PgOutcomeClaimRequest, t as PgOutcomeExecutionRequest, u as PgOutcomeNonTransactionalRequest, v as PgOutcomeReadBackFactory, w as PgOutcomeRecoveryRequest, x as PgOutcomeRecoveryResult, y as PgOutcomeResolution, z as PgOutcomeResolutionAppendResult, A as PgOutcomeResult, B as PgOutcomeTransactionalRequest, F as PgReinitializePreflightOptions, H as PgReinitializePreflightPool, I as SchemaChange, J as TransitionRunIdentityMismatchError, K as acquirePgLedgerLocks, L as appendIntentJournal, M as appendTransitionAuthorization, N as assertDeclarableChangeKind, O as assertGeneratedPostconditionSession, Q as compareSchemata, R as createPgTransitionRunPersister, U as createPgsqlGeneratedManagedStep, V as decodeGeneratedPostcondition, W as decodeGeneratedPostconditionPayload, X as ensureDbspMetaLedger, Y as ensurePgLedger, Z as ensurePgLedgerStorageVersion, _ as ensureTransitionJournal, $ as executePgAdmittedOperation, a0 as generatedPostconditionDigest, a1 as generatedPostconditionForChange, a2 as readPgCatalogueIdentity, a3 as readPgLedgerMarker, a4 as readPgLedgerReservationsForExecution, a5 as readPgLedgerScopeCurrency, a6 as readPgOutcomeRecoveryReadBack, a7 as readTransitionJournal, a8 as readVerifiedPgLedgerReservationsForPair, a9 as recordPgLedgerIdentity, aa as renderCreateDbspMetaSchemaSql, ab as renderCreateLedgerEventTableSql, ac as renderCreateLedgerIdentityTableSql, ad as renderCreateLedgerImmutabilityFunctionSql, ae as renderCreateLedgerImmutabilityTriggerSql, af as renderCreateLedgerMarkerTableSql, ag as renderCreateLedgerReservationTableSql, ah as renderCreateLedgerTerminalMemberIndexSql, ai as renderCreateTransitionAuthorizationTableSql, aj as renderCreateTransitionJournalTableSql, ak as renderCreateTransitionRunPlanTableSql, al as renderCreateTransitionRunTableSql, am as runPgReinitializePreflight, an as toGeneratedPostconditionBindingAddress, ao as validatePgLedgerRuntimeIntegrity, ap as verifyGeneratedCheckPostcondition, aq as verifyGeneratedColumnPostcondition, ar as verifyGeneratedIdentityPostcondition, as as verifyGeneratedIndexPostcondition, at as verifyGeneratedTablePostcondition, au as withGeneratedPostconditionSession } from './outcome-protocol-CACJDzli.js';
-import { Pool, PoolClient } from 'pg';
-import '@dbsp/core/internal';
-
-/**
- * Default primary key column name used as convention fallback
- * when schema metadata doesn't provide an explicit PK.
- *
- * Consumers (handlers, compiler) must NOT use this directly —
- * they use `requiredColumn()` to throw on missing data.
- * Only convention mappers (extractors, introspection) should reference this.
- */
-declare const DEFAULT_PK_COLUMN = "id";
-/**
- * Derive a foreign key column name from a table name and the PK column it references.
- *
- * Convention: `${singularTableName}_${pkColumnName}`
- * e.g. (authors, id) → author_id, (categories, id) → category_id
- *
- * Consumers should use `deriveFkColumnName` from CompilerContext or options
- * for configurable behavior.
- */
-type FkColumnDerivation = (tableName: string, pkColumnName: string) => string;
-declare const defaultFkDerivation: FkColumnDerivation;
-
-/**
- * NamingPlugin - Identifier transformation between model and database naming conventions
- *
- * Inspired by Kysely's CamelCasePlugin architecture.
- * The plugin transforms identifiers bidirectionally:
- * - toDatabase: model name (camelCase) → database name (snake_case)
- * - toModel: database name (snake_case) → model name (camelCase)
- */
-/**
- * Interface for naming convention transformation plugins
- */
-interface NamingPlugin {
-    /**
-     * Transform a model identifier to database format
-     * Example: "createdAt" → "created_at"
-     */
-    toDatabase(identifier: string): string;
-    /**
-     * Transform a database identifier to model format
-     * Example: "created_at" → "createdAt"
-     */
-    toModel(identifier: string): string;
-}
-/**
- * Identity plugin - no transformation
- * Use this when model and database naming conventions match
- */
-declare class IdentityNamingPlugin implements NamingPlugin {
-    toDatabase(identifier: string): string;
-    toModel(identifier: string): string;
-}
-/**
- * CamelCase ↔ snake_case transformation plugin
- *
- * Follows the same logic as Kysely's CamelCasePlugin:
- * - Handles consecutive uppercase letters (e.g., "parseJSON" → "parse_json")
- * - Handles numbers (e.g., "field1Name" → "field1_name")
- * - Preserves leading underscores
- */
-declare class CamelCaseNamingPlugin implements NamingPlugin {
-    /**
-     * camelCase → snake_case
-     */
-    toDatabase(identifier: string): string;
-    /**
-     * snake_case → camelCase
-     */
-    toModel(identifier: string): string;
-}
-/**
- * Singleton instances for convenience
- */
-declare const identityNaming: IdentityNamingPlugin;
-declare const camelCaseNaming: CamelCaseNamingPlugin;
-/**
- * Get a naming plugin by DbCasing (intuitive semantics).
- * - `'snake_case'`: DB uses snake_case → CamelCaseNamingPlugin (transforms to camelCase)
- * - `'camelCase'`: DB uses camelCase → IdentityNamingPlugin (no transform)
- * - `'preserve'`: No transformation → IdentityNamingPlugin
- */
-declare function getNamingPluginForDbCasing(casing: 'snake_case' | 'camelCase' | 'preserve'): NamingPlugin;
+import { PoolClient, Pool } from 'pg';
+export { escapeDiagnosticText } from '@dbsp/core/internal';
 
 /**
  * Internal registry of NQL `| bind name` CTE names visible to a compile pass.
@@ -103,6 +20,47 @@ declare function getNamingPluginForDbCasing(casing: 'snake_case' | 'camelCase' |
 
 type BindingNameRegistry = ReadonlySet<string>;
 
+declare const projectionEnvelopeBrand: unique symbol;
+type ProjectionEnvelope<T = unknown> = {
+    readonly [projectionEnvelopeBrand]: true;
+    readonly sql: string;
+    readonly parameters: readonly unknown[];
+    readonly ast?: Node;
+    readonly projection: ProjectionState;
+    readonly hydrationPlan?: PlanReport;
+    readonly __resultType?: T;
+};
+type ProjectionState = {
+    readonly kind: 'known';
+    readonly outputs: ReadonlyMap<string, OutputProjection>;
+} | {
+    readonly kind: 'dropped';
+    readonly reason: ProjectionDropReason;
+    readonly hadConvertibleSource: boolean;
+};
+type OutputProjection = OutputDescriptor;
+
+type ProjectionDropReason = 'set-operation-positional-merge' | 'raw-recursive-cte-positional-merge' | 'unknown-raw-sql' | 'unsupported-source';
+
+/**
+ * Resolves the columns available through a relation target.  A query-local
+ * binding shadows a physical relation, so its (when known) projection is the
+ * authority for every column emitted against that target.
+ */
+
+type RelationTargetProjectionRegistry = ReadonlyMap<string, ProjectionEnvelope>;
+/** A query-scope binding from an emitted SQL alias to the relation it exposes. */
+type AliasColumnAuthority = ReadonlyMap<string, ResolvedRelationTarget>;
+type ResolvedRelationTarget = {
+    readonly target: string;
+    readonly cteName?: string;
+    readonly outputs?: ReadonlyMap<string, OutputDescriptor>;
+};
+
+/** Built-in include strategies, shared by the runtime registry and public types. */
+declare const INCLUDE_STRATEGIES: readonly ["join", "lateral", "json_agg", "cte"];
+/** The four strategies this adapter implements handlers for, distinct from @dbsp/types' six-member IncludeStrategy, which includes the planner's subquery and auto. */
+type IncludeHandlerStrategy = (typeof INCLUDE_STRATEGIES)[number];
 /**
  * Immutable context passed to all handlers during compilation.
  */
@@ -131,6 +89,10 @@ interface CompilerContext {
     readonly outerAlias?: string;
     /** Query-local CTE/binding names that must not be schema-qualified. */
     readonly bindingNames?: BindingNameRegistry;
+    /** Known projections for visible CTE/binding relation targets. */
+    readonly relationTargetProjections?: RelationTargetProjectionRegistry;
+    /** Lexically visible SQL aliases that expose a known CTE projection. */
+    readonly aliasColumnAuthorities?: AliasColumnAuthority;
     /**
      * Optional callback to compile a QueryIntent into an AST Node (SubLink subselect).
      * Set by PlanCompiler when compiling selectCustomExpression — enables SubqueryExpressionIntent
@@ -213,7 +175,7 @@ interface Decision {
     readonly offset?: number | ParamIntent | {
         paramIndex: number;
     };
-    readonly strategy?: 'join' | 'lateral' | 'json_agg' | 'cte';
+    readonly strategy?: IncludeHandlerStrategy;
     readonly relation?: string;
     readonly relationName?: string;
     readonly relationPath?: string;
@@ -293,6 +255,8 @@ interface WhereHandler {
 }
 /**
  * Dispatcher for recursive WHERE compilation.
+ * The same function object may be passed to every level of a recursive compilation, so it is an opaque callback.
+ * Handlers must not use its identity to distinguish frames or carry frame-local state.
  */
 type WhereDispatcher = (decision: Decision, ctx: CompilerContext, state: CompilerState) => Node;
 /**
@@ -324,7 +288,7 @@ interface ExpressionHandler {
  */
 interface IncludeHandler {
     /** Strategy this handler implements */
-    readonly strategy: 'join' | 'lateral' | 'json_agg' | 'cte';
+    readonly strategy: IncludeHandlerStrategy;
     /**
      * Compile an include to AST.
      * @param decision The include decision
@@ -532,6 +496,7 @@ interface CompilerOptions {
     readonly model?: _dbsp_types.ModelIR;
     /** Query-local CTE/binding names that must not be schema-qualified. */
     readonly bindingNames?: BindingNameRegistry;
+    readonly relationTargetProjections?: RelationTargetProjectionRegistry;
 }
 declare class PlanCompiler {
     private readonly naming;
@@ -541,6 +506,7 @@ declare class PlanCompiler {
     private readonly model;
     private readonly dialectCapabilities;
     private readonly bindingNames;
+    private readonly relationTargetProjections;
     /** Mutable state shared with extracted condition/value compilation functions */
     private state;
     /** Track root table for EXISTS FK correlation */
@@ -559,19 +525,35 @@ declare class PlanCompiler {
      * correct source alias (e.g., 'callee.file' reads parent path 'callee').
      */
     private joinAliasMap;
+    /**
+     * Immutable-before-emission mapping from a public relation qualifier to the
+     * SQL alias that is actually emitted for that relation.
+     */
+    private visibleSqlQualifiers;
     /**
      * Tracks all join aliases in use for the current query.
      * Entries are stored in emitted database-alias space, after naming.toDatabase().
      * Ensures no two JOINs share the same alias (DOUBLE-ALIAS prevention).
      */
     private usedJoinAliases;
+    /**
+     * Query-local authority for every emitted non-root alias.  Root bindings are
+     * deliberately absent: an unqualified root reference retains its historical
+     * SQL semantics, even when the root happens to be a reduced CTE.
+     */
+    private aliasColumnAuthorities;
     constructor(options?: CompilerOptions);
     private childCompilerOptions;
     /** Build immutable context for handler-based WHERE compilation */
     private handlerCtx;
+    private relationTargetContext;
+    /** Register an emitted alias before any column-reference path can use it. */
+    private registerAliasAuthority;
     private findAliasForLegacySourceTable;
     private emittedJoinAlias;
     private resolvedJoinAliases;
+    private resolveVisibleSqlQualifier;
+    private filterJoinAlias;
     /**
      * Dispatch a PlanDecision through the unified WHERE handler system.
      * Bridges PlanCompiler's state to handler types, calls dispatcher, syncs back.
@@ -635,6 +617,12 @@ declare class PlanCompiler {
     private registerIncludeCompilationResult;
     private compileIncludeDecision;
     private compileJoinIncludeAllocationPass;
+    /**
+     * Allocate visible SQL qualifiers before compiling a target. Only emitted
+     * joins register their public qualifier; strategies without an outer source
+     * deliberately leave their relation unavailable to qualified references.
+     */
+    private allocateVisibleSqlQualifiers;
     /**
      * Fold a WHERE-family decision into an existing where expression.
      * Returns the updated (or new) where node.
@@ -733,93 +721,6 @@ declare function compilePlan(plan: SimplifiedPlanReport, options?: CompilerOptio
 
 declare function dbTypesEqual(a: string, b: string): boolean;
 
-type IndexRenderKey = {
-    readonly column?: string | undefined;
-    readonly expression?: string | undefined;
-    readonly opclass?: string | undefined;
-};
-type IndexRenderSpec = {
-    readonly name: string;
-    readonly table: string;
-    readonly schema?: string | undefined;
-    readonly unique: boolean;
-    readonly method?: string | undefined;
-    readonly keys: readonly IndexRenderKey[];
-    readonly include?: readonly string[] | undefined;
-    readonly nullsNotDistinct?: boolean | undefined;
-    readonly with?: Readonly<Record<string, unknown>> | undefined;
-    readonly where?: string | undefined;
-    /** The in-process index value that owns a deparsed `where` predicate. */
-    readonly whereSource?: IndexIR | undefined;
-    readonly concurrently?: boolean | undefined;
-    readonly ifNotExists?: boolean | undefined;
-};
-type IndexCapabilityContext = {
-    readonly caps: DialectCapabilities;
-    readonly targetVersion?: string | undefined;
-};
-type IndexFeature = 'INCLUDE' | 'PARTIAL INDEX' | 'EXPRESSION INDEX' | 'INDEX METHOD' | 'OPCLASS' | 'NULLS NOT DISTINCT';
-declare class IndexFeatureUnsupportedError extends Error {
-    readonly indexName: string;
-    readonly unsupportedFeatures: readonly IndexFeature[];
-    constructor(indexName: string, unsupportedFeatures: readonly IndexFeature[], message: string);
-}
-declare function assertCreateIndexSupported(spec: IndexRenderSpec, ctx?: IndexCapabilityContext): void;
-declare function assertCreateIndexesSupported(specs: readonly IndexRenderSpec[], ctx?: IndexCapabilityContext): void;
-declare function renderCreateIndex(spec: IndexRenderSpec, ctx?: IndexCapabilityContext): string;
-
-/**
- * DDL Generator - Generates PostgreSQL DDL statements from ModelIR
- *
- * Generates SQL strings directly for better compatibility and control.
- * Two-pass strategy handles circular FK dependencies.
- *
- * @module ddl/ddl-generator
- */
-
-interface GenerateDDLOptions {
-    /** Include DROP TABLE IF EXISTS statements before CREATE TABLE */
-    readonly includeDropStatements?: boolean;
-    /**
-     * Database schema name (e.g., 'public', 'tenant_123').
-     * Required when emitted DDL would otherwise mix non-default target-scoped
-     * custom types/enums with unqualified table SQL.
-     */
-    readonly schemaName?: string;
-    /**
-     * Automatically create indexes on foreign key columns.
-     * FK columns are frequently used in JOINs, so indexing is a best practice.
-     * @default true
-     */
-    readonly fkAutoIndex?: boolean;
-    /** Naming plugin for identifier transformation */
-    readonly naming?: NamingPlugin;
-    /** Dialect capabilities — unsupported index features throw during DDL generation */
-    readonly dialectCapabilities?: DialectCapabilities;
-}
-/**
- * Generate DDL statements from a ModelIR schema.
- *
- * Uses a two-pass approach to handle circular FK dependencies:
- * 1. CREATE TABLE (without FK constraints)
- * 2. ALTER TABLE ADD CONSTRAINT for foreign keys
- * 3. CREATE INDEX (explicit + auto-generated for FKs)
- *
- * @param schema - The ModelIR schema to generate DDL from
- * @param options - Optional configuration
- * @returns Array of DDL statements in dependency order
- */
-declare function generateDDL(schema: ModelIR, options?: GenerateDDLOptions): string[];
-declare function generateCreateIndex(tableName: string, idx: IndexIR, schemaName: string | undefined, naming: NamingPlugin, context?: IndexCapabilityContext, ifNotExists?: boolean): string;
-/**
- * Returns whether the PostgreSQL DDL generator can emit this IndexIR.
- *
- * Keep this as the single representability predicate for generated schema
- * omission and destructive-drop classification: both sides must agree on the
- * exact validation surface used by generateCreateIndex().
- */
-declare function canGenerateCreateIndex(tableName: string, idx: IndexIR, schemaName?: string | undefined, naming?: NamingPlugin): boolean;
-
 /** EFF-04's closed generated-mutation result domain. */
 type GeneratedMutationClassification = 'non-destructive' | 'removal' | 'data-destructive'
 /** A table rename is executed only by the paired re-address protocol. */
@@ -839,1045 +740,31 @@ declare function refusesRecordedPlanRemoval(kind: ChangeKind | string, change?:
     readonly destructive?: boolean;
 }): boolean;
 
-/**
- * PostgreSQL Schema Introspection (ADAPTER-006)
- *
- * Queries information_schema/pg_catalog to build ModelIR
- * from an existing database. Supports:
- * - Table/column/PK discovery
- * - FK → bidirectional relation inference
- * - Hierarchy detection (adjacency + edge-table)
- * - Include/exclude filtering
- *
- * @module introspection
- */
-
-/** The minimum every schema-level operation needs: which schema. */
-interface SchemaScopeOptions {
-    /** Schema name to operate on (default: 'public') */
-    readonly schema?: string;
-}
-/**
- * Introspection additionally chooses WHICH TABLES to read. It is a read-only
- * path, so narrowing it is safe — that is why the table filters live here and
- * nowhere else.
- */
-interface IntrospectionOptions extends SchemaScopeOptions {
-    /** Tables to exclude (glob patterns: * matches any chars) */
-    readonly exclude?: readonly string[];
-    /** Tables to include (default: all). Applied before exclude. */
-    readonly include?: readonly string[];
-}
-/** Hierarchy pattern detected during introspection */
-/**
- * Hierarchy pattern detected during introspection.
- * Alias of {@link HierarchyIR} from \@dbsp/types — kept here for
- * public-API backwards compatibility (re-exported from \@dbsp/adapter-pgsql).
- */
-type DetectedHierarchy = HierarchyIR;
-/** Extended ModelIR with hierarchy metadata */
-interface IntrospectedModelIR extends ModelIR {
-    readonly hierarchies: readonly DetectedHierarchy[];
-    readonly introspectedAt: Date;
-    readonly warnings: readonly string[];
-}
-/**
- * Introspect a database through a pool.
- *
- * This does NOT accept a checked-out `PoolClient`, and that is deliberate. A
- * client may be sitting inside a transaction that belongs to its owner, and a
- * catalog query that fails there aborts *their* transaction. Protecting that
- * needs a savepoint, and knowing whether to take one needs the caller to say
- * whose transaction it is — which is what `PgsqlAdapter`'s `borrowedClient`
- * declaration is for. Guessing it from the object's shape is the exact defect
- * this adapter was rewritten to remove.
- *
- * Saying so in a comment is not enough: `CatalogQueryExecutor` is structural, so
- * a `PoolClient` — which has a `query()` — satisfies it, and the prose would have
- * been the only thing standing in the way. It is branded instead, and only the
- * adapter's own protected executor carries the brand. A client cannot be passed
- * here at all.
- *
- * So: hold a client, use `new PgsqlAdapter(client, { borrowedClient: true })`
- * and call `.introspect()` on it.
- */
-declare function introspect(pool: Pool, options?: IntrospectionOptions): Promise<IntrospectedModelIR>;
-
-type PgsqlTransactionTimeoutParameter = 'lock_timeout' | 'statement_timeout';
-
-/**
- * PgsqlAdapter - Implements the Adapter interface for PostgreSQL using native pg driver.
- *
- * This adapter wraps a pg Pool instance and provides the unified
- * adapter interface for the db-semantic-planner ORM.
- *
- * @module pgsql-adapter
- */
-
-declare const rollbackOnlyPgsqlScopeBrand: unique symbol;
-/** A scope minted by withScratchScope and guaranteed to roll back on success. */
-type RollbackOnlyPgsqlScope<DB = unknown> = PgsqlAdapter<DB> & {
-    readonly [rollbackOnlyPgsqlScopeBrand]: typeof rollbackOnlyPgsqlScopeBrand;
+/** Durable payload roles are disjoint before the outcome protocol serializes them. */
+type GeneratedIdentityObservation = LedgerPayload & {
+    readonly payloadKind: 'generated-identity-observation';
 };
-type PgAdvisoryLockKey = bigint | {
-    readonly classId: number;
-    readonly objId: number;
+type GeneratedStructuralObservation = LedgerPayload & {
+    readonly payloadKind: 'generated-structural-observation';
 };
-type PgAdvisoryLockResult<T> = {
-    readonly acquired: true;
-    readonly value: T;
-} | {
-    readonly acquired: false;
+type GeneratedPostconditionObservation = GeneratedIdentityObservation | GeneratedStructuralObservation;
+type GeneratedPostconditionReadBack = {
+    readonly observed: GeneratedPostconditionObservation;
+    readonly catalogueIdentity?: NonNullable<LedgerAddress['catalogueIdentity']>;
 };
-declare class PgsqlRawSqlTransactionControlError extends Error {
-    readonly dbspRawSqlTransactionControl = true;
-    constructor(cause: unknown);
-}
-declare class PgsqlTransactionAbortedCommitError extends Error {
-    readonly dbspTransactionAbortedCommit = true;
-    constructor(cause: unknown);
-}
-declare class PgsqlTransactionAbortedError extends Error {
-    readonly dbspTransactionAborted = true;
-    constructor(cause: unknown);
-}
 /**
- * Raised when a pool-owned top-level transaction is aborted through
- * `TransactionOptions.signal`. If the signal aborts while `pool.connect()` is
- * still pending, dbsp honors it only after a client is acquired.
+ * Reads a generated declaration's terminal observation and catalogue identity.
+ * The decoded declaration remains module-private so every public path enters
+ * through the versioned decoder before it can dispatch on a declaration kind.
  */
-declare class PgsqlTransactionAbortSignalError extends Error {
-    readonly dbspTransactionAbortSignal = true;
-    constructor();
-}
-declare class PgsqlPinnedConnectionAbortSignalError extends Error {
-    readonly dbspPinnedConnectionAbortSignal = true;
-    constructor();
-}
-declare class PgsqlTransactionOptionsError extends Error {
-    readonly dbspTransactionOptions = true;
-    constructor(message: string);
-}
-declare class PgsqlAdvisoryLockOptionsError extends Error {
-    readonly dbspAdvisoryLockOptions = true;
-    constructor(message: string);
-}
-/**
- * Raised when a statement inside a dbsp-managed transaction fails with a SQLSTATE
- * that matches a timeout the caller configured for that transaction: `55P03`
- * (`lock_not_available`) when `lockTimeoutMs` was set, or `57014` (`query_canceled`)
- * when `statementTimeoutMs` was set. The original PostgreSQL error is preserved as
- * `cause`.
- *
- * Classification is by SQLSTATE only. PostgreSQL assigns these codes to the OUTCOME,
- * not the cause: `55P03` is also raised by `FOR UPDATE NOWAIT`, and `57014` is also
- * raised by an external cancel (e.g. `pg_cancel_backend`). There is no locale-stable
- * structured field that separates the timeout from the other cause, so the message
- * text is deliberately NOT parsed. dbsp never emits `NOWAIT` itself, so a `55P03`
- * here is the configured `lock_timeout` unless the caller's own raw SQL used
- * `NOWAIT`; a `57014` is the configured `statement_timeout` unless the backend was
- * cancelled from outside. Inspect `cause` when that distinction matters.
- */
-declare class PgsqlTransactionTimeoutError extends Error {
-    readonly timeout: PgsqlTransactionTimeoutParameter;
-    readonly dbspTransactionTimeout = true;
-    constructor(cause: unknown, timeout: PgsqlTransactionTimeoutParameter);
-}
-/**
- * Raised when the single safe unnamed replay after a prepared-statement
- * infrastructure failure also fails. `message` is always the safe constant
- * `Prepared statement recovery replay failed.`; `cause` is the replay error;
- * `infrastructureError` is the original infrastructure error; and
- * `admissionFingerprint` identifies the admitted statement. DBSP-authored
- * messages carry no parameter values; preserved upstream errors, including the
- * standard Error `cause`, are unsanitized.
- */
-declare class PgsqlPreparedStatementReplayError extends Error {
-    readonly admissionFingerprint: string;
-    readonly infrastructureError: unknown;
-    readonly dbspPreparedStatementReplay = true;
-    readonly originalInfrastructureError: unknown;
-    readonly originalError: unknown;
-    constructor(admissionFingerprint: string, infrastructureError: unknown, cause: unknown);
-}
+declare function readGeneratedPostconditionReadBack(executor: GeneratedPostconditionSession, step: NormalizedManagedStep, address: LedgerAddress): Promise<GeneratedPostconditionReadBack>;
 /**
- * Options for PgsqlAdapter.
+ * Generated DDL has no operation runtime to supply an observation. Structural
+ * declarations read the precise catalogue fields they change; the four #597
+ * identity-only declarations prove existence and catalogue identity, not shape.
+ * A same-named object is never enough to write an `observed` terminal.
  */
-interface PgsqlPreparedStatementsOptions {
-    /** Maximum distinct compiled statements admitted per executor (default: 500). */
-    readonly maxStatements?: number;
-}
-interface PgsqlAdapterOptions {
-    /** Schema name for multi-tenant queries */
-    readonly schemaName?: string;
-    /**
-     * DB column casing convention (intuitive semantics).
-     * - `'snake_case'`: DB columns are snake_case → transform to camelCase for JS
-     * - `'camelCase'`: DB columns are camelCase → no transformation
-     * - `'preserve'`: No transformation
-     */
-    readonly dbCasing?: DbCasing;
-    /** Optional model for WHERE compilation */
-    readonly model?: ModelIR;
-    /** Optional logger for debug/error messages */
-    readonly logger?: AdapterLogger;
-    /** Default primary key column name for convention fallbacks (default: 'id') */
-    readonly defaultPkColumnName?: string;
-    /** Convention for deriving FK column names: (tableName, pkName) => fkColumnName */
-    readonly deriveFkColumnName?: FkColumnDerivation;
-    /**
-     * Opt in to node-postgres named prepared statements for compiled queries with
-     * parameters. `true` uses the default statement cap; an object overrides it.
-     */
-    readonly preparedStatements?: boolean | PgsqlPreparedStatementsOptions;
-}
-interface PgsqlPoolAdapterOptionsBase extends PgsqlAdapterOptions {
-    readonly borrowedClient?: false;
-}
-type PgsqlPoolAdapterOptions = (PgsqlPoolAdapterOptionsBase & {
-    readonly replayInvalidatedPlans?: false | undefined;
-}) | (Omit<PgsqlPoolAdapterOptionsBase, 'preparedStatements'> & {
-    readonly preparedStatements: true | PgsqlPreparedStatementsOptions;
-    /**
-     * Enable one unnamed replay after `0A000`/`RevalidateCachedQuery` only when
-     * you assert that your statements do not invoke functions performing
-     * effectful work before nested prepared-statement operations. This requires
-     * `preparedStatements: true` (or a prepared-statements options object).
-     *
-     * Replay snapshots JSON-like values (finite numbers, strings, booleans,
-     * `null`, arrays, plain or null-prototype objects) and clean `Date`/`Buffer`
-     * instances. It excludes non-finite numbers, `undefined`, `bigint`, functions,
-     * proxies, cycles, sparse arrays, accessors, symbol-valued
-     * parameters, symbol keys on plain objects, exotic prototypes, custom built-ins,
-     * and values with their own node-postgres
-     * `toPostgres` behavior.
-     * Serialization-irrelevant symbol metadata on arrays and Buffers is ignored.
-     * The detached snapshot covers later mutations to the supplied value graph,
-     * not built-in prototypes, timezone state, or node-postgres serialization
-     * configuration; a process-global `toPostgres` or `toJSON` installed while
-     * the call is in flight is outside the guarantee. Each capture or replay copy
-     * is independently limited to 64 Ki visited values, 16 MiB of UTF-8 strings,
-     * and 16 MiB of Buffer data. An ineligible or over-budget value still receives
-     * the initial named submission, but disables transparent replay.
-     * These budgets bound copied nodes and payload bytes; enumerating a plain
-     * object's existing property table is proportional to the caller's own object.
-     *
-     * Replay needs the adapter-owned serialized physical client available from a
-     * pool; it is therefore not supported by borrowed or compile-only adapters.
-     */
-    readonly replayInvalidatedPlans: true;
-});
-interface PgsqlBorrowedClientAdapterOptions extends PgsqlAdapterOptions {
-    /** Replay is only available to a pool-owned pinned scope. */
-    readonly replayInvalidatedPlans?: never;
-    /** This connection belongs to the caller. dbsp never releases it. */
-    readonly borrowedClient: true;
-    /**
-     * Let dbsp run transactions on your connection, through a savepoint.
-     *
-     * When your connection is already inside a transaction, dbsp creates a
-     * savepoint and rolls back dbsp's changes after that savepoint if the callback
-     * fails. `RELEASE SAVEPOINT` does not commit; it merges the work into your
-     * surrounding transaction, so a callback that succeeded is still undone if you
-     * later roll back. Deferred constraints or triggers can still make your outer
-     * `COMMIT` fail after dbsp has returned. `SET LOCAL` changes inside the callback
-     * remain in effect for the rest of your transaction after the savepoint is
-     * released. `ON COMMIT DROP` and `ON COMMIT DELETE ROWS` fire at your transaction
-     * boundary, not at the savepoint. Sequences are not transactional:
-     * `nextval`/`setval` are not reclaimed by a savepoint rollback. Session-level
-     * advisory locks ignore rollback; transaction-level advisory locks taken by a
-     * successful callback last until your transaction ends.
-     *
-     * Transaction control through raw SQL inside a scope dbsp is managing is
-     * unsupported. `COMMIT`, `ROLLBACK`, and `PREPARE TRANSACTION` end the
-     * transaction dbsp is working inside; dbsp detects that and fails loudly, but
-     * the data is already whatever your statement made it. Raw savepoint control
-     * (`SAVEPOINT`, `RELEASE SAVEPOINT`, `ROLLBACK TO SAVEPOINT`) can alter the
-     * savepoint stack before dbsp sees the command tag; dbsp poisons the scope, but
-     * it cannot make that command un-run. Manage your transaction outside dbsp's
-     * calls.
-     */
-    readonly managedTransactions?: true;
-}
-/** Options for a connectionless adapter, which cannot own replay serialization. */
-interface PgsqlCompileOnlyAdapterOptions extends PgsqlAdapterOptions {
-    readonly replayInvalidatedPlans?: never;
-}
-/**
- * Adapter implementation for PostgreSQL using native pg driver.
- *
- * @typeParam DB - Database schema type
- *
- * @example
- * ```typescript
- * import { Pool } from 'pg';
- * import { createPgsqlAdapter } from '@dbsp/adapter-pgsql';
- *
- * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
- * const adapter = createPgsqlAdapter(pool);
- * const orm = createOrm({ model, adapter });
- * ```
- */
-declare class PgsqlAdapter<DB = unknown> implements Adapter<DB> {
-    private readonly pool;
-    private readonly client;
-    private readonly borrowedClient;
-    private readonly managedTransactions;
-    private readonly adapterManagedTransaction;
-    private readonly adapterManagedPinnedConnection;
-    private readonly rollbackOnlyScope;
-    private readonly scopeToken;
-    private readonly scopeState;
-    private readonly schemaName;
-    private readonly _dbCasing;
-    private readonly naming;
-    private readonly model;
-    private readonly logger;
-    private readonly replayInvalidatedPlans;
-    private readonly preparedStatements;
-    private readonly preparedStatementRegistry;
-    private readonly _capabilities;
-    private readonly defaultPk;
-    private readonly deriveFk;
-    /**
-     * Create a new PgsqlAdapter.
-     *
-     * Ownership of the connection is **declared**, never inferred. Handing over a
-     * `PoolClient` means nothing on its own — it says the object has a `release()`
-     * method, not that a transaction is open or that the caller owns the lifecycle.
-     * Pass `borrowedClient: true` to say so.
-     *
-     * @param pool - a pg.Pool, a caller-owned pg.PoolClient (with `borrowedClient: true`),
-     *   or nothing at all for compile-only mode
-     * @param options - configuration; declares connection ownership
-     */
-    constructor(pool: Pool, options?: PgsqlPoolAdapterOptions);
-    constructor(client: PoolClient, options: PgsqlBorrowedClientAdapterOptions);
-    constructor(pool?: undefined, options?: PgsqlCompileOnlyAdapterOptions);
-    /**
-     * Shared compilation dependencies — built lazily from adapter fields.
-     * Passed to compiler sub-modules instead of `this`.
-     */
-    /**
-     * Return a new PgsqlAdapterOptions that merges current config with overrides.
-     * Ensures that all configuration fields (logger, defaultPkColumnName,
-     * deriveFkColumnName, etc.) are propagated to scoped/transactional adapters.
-     */
-    private cloneOptions;
-    private buildCompileDeps;
-    private requireNqlCompileModel;
-    private assertNqlBindingNamesDisjointFromTables;
-    private compileNqlMutation;
-    private compileNqlBundleLeafEnvelope;
-    private compileNqlBundle;
-    /**
-     * Returns the pool/client executor, or refuses a connectionless adapter.
-     */
-    private requireConnection;
-    /** Adapter capabilities for feature detection */
-    get capabilities(): AdapterCapabilities;
-    /** Per-instance connection state, distinct from PostgreSQL capabilities. */
-    get connectionAvailability(): ConnectionAvailability;
-    /** Side-effect-free execution availability for core feature detection. */
-    executionAvailable(): boolean;
-    /** PostgreSQL dialect capabilities for planner strategy selection */
-    get dialectCapabilities(): DialectCapabilities;
-    /**
-     * DB column casing convention used by this adapter.
-     */
-    get dbCasing(): DbCasing;
-    /**
-     * Get the underlying pg Pool or borrowed PoolClient instance.
-     *
-     * Exposing raw access from a pool-owned dbsp-managed scope permanently taints that
-     * physical client: external callers can queue commands outside dbsp's statement
-     * lock, so replay is disabled and dbsp destroys the client at scope release.
-     * Expect pool churn; session state on that exposed connection does not survive the
-     * release. A borrowed client remains caller-owned: dbsp never releases it, and the
-     * caller decides its fate after raw exposure.
-     */
-    getPoolInstance(): Pool | PoolClient;
-    /**
-     * Compile a plan to executable SQL.
-     *
-     * When passed a direct `CompiledNqlQuery`, the adapter trusts that the bundle
-     * has already been semantically validated by the NQL compiler. This method
-     * still performs adapter-owned SQL safety checks for emitted binding names
-     * before CTE emission.
-     */
-    compile<T = unknown>(plan: PlanReport | CompiledNqlQuery, options?: CompileOptions): CompiledQuery<T>;
-    /**
-     * Compile a plan with includes, returning subquery include metadata (DX-033).
-     */
-    compileWithIncludes<T = unknown>(plan: PlanReport, options?: CompileOptions): CompileResultWithIncludes<T>;
-    /**
-     * Compile a subquery include query for given parent IDs (DX-033).
-     * Generates: SELECT * FROM targetTable WHERE foreignKey IN ($1, $2, ...)
-     *
-     * @param info - Subquery include metadata
-     * @param parentIds - Parent record IDs to fetch related records for
-     * @param options - Compile options
-     * @returns Compiled query for fetching related records
-     */
-    compileSubqueryInclude(info: SubqueryIncludeInfo, parentIds: readonly unknown[], options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile a FROM-less SELECT expression to SQL.
-     *
-     * Produces: SELECT <expr>
-     * Example: SELECT nextval('my_seq')
-     *
-     * @param expr - ExpressionIntent to evaluate
-     * @returns Compiled SQL and parameters
-     */
-    compileSelectExpression<T = unknown>(expr: ExpressionIntent): CompiledQuery<T>;
-    /**
-     * Compile an insert intent to executable SQL.
-     *
-     * Strategy switch (per CompileOptions):
-     * - rows <= batchThreshold (default 50): VALUES ($1,$2),($3,$4),...
-     * - rows > batchThreshold OR batchThreshold === 0: SELECT unnest($1::type[]),...
-     */
-    compileInsert(intent: InsertIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile an insert-from intent to executable SQL (NQL-ALIGN).
-     * INSERT INTO target (cols) SELECT cols FROM source WHERE ... LIMIT ... RETURNING ...
-     */
-    compileInsertFrom(intent: InsertFromIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile an update intent to executable SQL.
-     */
-    compileUpdate(intent: UpdateIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile a batch update intent to executable SQL using unnest FROM strategy (BATCH-001).
-     *
-     * Generates:
-     *   UPDATE "table" SET "update_col" = t."update_col" [, "scalar_col" = $N]
-     *   FROM unnest(CAST($1 AS type[]), CAST($2 AS type[])) AS t("match_col", "update_col")
-     *   WHERE "table"."match_col" = t."match_col"
-     *   [RETURNING ...]
-     */
-    compileBatchUpdate(intent: BatchUpdateIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile a delete intent to executable SQL.
-     */
-    compileDelete(intent: DeleteIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile an upsert intent to executable SQL (DX-026).
-     */
-    compileUpsert(intent: UpsertIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile an upsert-from intent to executable SQL (NQL-BIND).
-     * INSERT INTO target SELECT ... FROM source ON CONFLICT (cols) DO UPDATE SET ...
-     */
-    compileUpsertFrom(intent: UpsertFromIntent, options?: CompileOptions): CompiledQuery;
-    /**
-     * Compile a recursive CTE plan to executable SQL.
-     * Supports adjacency-list and edge-table traversal modes.
-     */
-    compileRecursive<T = unknown>(report: RecursivePlanReport, model: ModelIR, options?: CompileOptions): CompiledQuery<T>;
-    /**
-     * Compile a CTE query backed by unnest() arrays (BATCH-001 Block 5).
-     *
-     * Strategy: compile CTE nodes to SQL fragments, compile outer query
-     * independently (parameters starting at $1), then renumber outer params
-     * to start after CTE params and prepend WITH clause.
-     */
-    compileCteQuery<T = unknown>(intent: CteQueryIntent, options?: CompileOptions): CompiledQuery<T>;
-    /**
-     * Compile a set operation (UNION / INTERSECT / EXCEPT) to SQL.
-     */
-    compileSetOperation<T = unknown>(intent: SetOperationIntent, model: ModelIR, options?: CompileOptions): CompiledQuery<T>;
-    private compileSetOperationWithBindings;
-    /**
-     * Create a dump for observability.
-     */
-    createDump(plan: PlanReport, query: CompiledQuery, meta?: DumpMeta): Dump;
-    /**
-     * Execute a query and return all results.
-     * Results are transformed to use model naming convention (e.g., snake_case → camelCase)
-     */
-    execute<T>(query: CompiledQuery<T>): Promise<T[]>;
-    /**
-     * Execute a query and return rows plus PostgreSQL result metadata.
-     * Results are transformed to use model naming convention (e.g., snake_case → camelCase)
-     */
-    executeWithMeta(query: CompiledQuery): Promise<{
-        readonly rows: readonly unknown[];
-        readonly rowCount: number;
-        readonly command?: string;
-    }>;
-    /**
-     * Transform result rows from database naming to model naming convention.
-     * For CamelCaseNamingPlugin: price_cents → priceCents
-     */
-    private transformResultRows;
-    /**
-     * Execute a query and return the first result or null.
-     */
-    executeOne<T>(query: CompiledQuery<T>): Promise<T | null>;
-    /**
-     * Execute a query and return the first result or throw.
-     */
-    executeOneOrThrow<T>(query: CompiledQuery<T>): Promise<T>;
-    /**
-     * Stream query results as an async iterable iterator.
-     * Uses PostgreSQL cursors for efficient streaming.
-     *
-     * Note: The cursor must be used within a transaction. If not already
-     * in a transaction, this method wraps the streaming in one.
-     *
-     * @param query - Compiled query to stream
-     * @param options - Stream options (chunkSize)
-     * @returns AsyncIterableIterator that yields rows one by one
-     */
-    stream<T>(query: CompiledQuery<T>, options?: AdapterStreamOptions): AsyncIterableIterator<T>;
-    /** Stream raw SQL directly using the same cursor machinery as stream(). */
-    streamRaw<T = unknown>(sql: string, parameters?: readonly unknown[], options?: AdapterStreamOptions): AsyncIterableIterator<T>;
-    private streamCursor;
-    /**
-     * Internal: Stream with an existing client using cursors.
-     */
-    private streamWithClient;
-    private streamWithManagedClient;
-    private streamWithManagedClientSavepointScope;
-    private streamWithClientTransaction;
-    /**
-     * Introspect the database schema and return a ModelIR.
-     *
-     * @param options - Optional introspection options (schema, include/exclude filters)
-     * @returns IntrospectedModelIR with tables, relations, and hierarchy metadata
-     *
-     * @example
-     * ```typescript
-     * const model = await adapter.introspect();
-     * const model = await adapter.introspect({ schema: 'tenant_1' });
-     * const model = await adapter.introspect({ exclude: ['_prisma*'] });
-     * ```
-     */
-    introspect(options?: IntrospectionOptions): Promise<IntrospectedModelIR>;
-    /**
-     * Acquire an exclusive session-level PostgreSQL advisory lock for the callback.
-     *
-     * The lock, callback, and unlock run on one `withPinnedConnection()` adapter.
-     * dbsp performs one PostgreSQL acquire and one matching unlock per call. It
-     * does not track reentrant depth in v1; PostgreSQL's session-level stacking
-     * still applies when callers deliberately nest on the same pinned adapter.
-     */
-    withAdvisoryLock<T>(key: PgAdvisoryLockKey, fn: (locked: Adapter<DB>) => Promise<T>): Promise<T>;
-    withAdvisoryLock<T>(key: PgAdvisoryLockKey, fn: (locked: Adapter<DB>) => Promise<T>, options: {
-        readonly wait?: 'block';
-        readonly signal?: AbortSignal;
-    }): Promise<T>;
-    withAdvisoryLock<T>(key: PgAdvisoryLockKey, fn: (locked: Adapter<DB>) => Promise<T>, options: {
-        readonly wait: 'try';
-        readonly signal?: AbortSignal;
-    }): Promise<PgAdvisoryLockResult<T>>;
-    withAdvisoryLock<T>(key: PgAdvisoryLockKey, fn: (locked: Adapter<DB>) => Promise<T>, options?: {
-        readonly wait?: 'block' | 'try';
-        readonly signal?: AbortSignal;
-    }): Promise<T | PgAdvisoryLockResult<T>>;
-    private unlockAdvisoryLock;
-    withPinnedConnection<T>(fn: (adapter: Adapter<DB>) => Promise<T>, options?: PinnedConnectionOptions): Promise<T>;
-    private pinnedConnectionReleaseReason;
-    private pinnedConnectionWithClient;
-    /**
-     * Execute a callback within a database transaction.
-     *
-     * ## What this guarantees
-     *
-     * The callback's work commits together or not at all; a statement issued inside
-     * the transaction never executes after its boundary, even if you forget to
-     * `await` it; a nested `transaction()` is a real savepoint; and the connection
-     * never goes back to the pool with a transaction still open on it.
-     *
-     * ## What it cannot guarantee, and you should know before you reach for raw SQL
-     *
-     * **Raw SQL that ends the transaction ends it.** `COMMIT`, `ROLLBACK` and
-     * `PREPARE TRANSACTION` issued through `executeRaw` — or through several commands
-     * in one call — reach PostgreSQL and take effect *before* dbsp is told what they
-     * were: the command tag arrives after the statement has run. dbsp detects it, kills
-     * the scope so nothing else escapes, and throws — but **it cannot un-run what your
-     * statement already did**, and `transaction()` rejecting does not mean nothing was
-     * committed.
-     *
-     * The same holds for session state raw SQL creates: a sequence that advanced stays
-     * advanced, an advisory lock stays held, a `PREPARE` or a `SET` you issued survives
-     * on a pooled connection. dbsp cleans up only what dbsp created.
-     *
-     * This is the contract of an escape hatch, not an oversight — see #327. If you need
-     * transaction control, own the transaction: take a client, `BEGIN` on it yourself,
-     * and hand dbsp a `borrowedClient` **without** `managedTransactions`. dbsp will then
-     * contain its own statements inside *your* transaction instead of the other way round.
-     */
-    transaction<T>(fn: (adapter: Adapter<DB>) => Promise<T>, options?: TransactionOptions): Promise<T>;
-    /**
-     * Execute scratch PostgreSQL work in a scope that always rolls back on success.
-     *
-     * This is intentionally PostgreSQL-adapter-specific. It is used for catalog
-     * shaped scratch DDL such as expression canonicalisation, where the caller
-     * needs PostgreSQL's rendering but must not keep the scratch objects. This
-     * scope has exactly one successful exit: rollback. In a caller transaction,
-     * only this outer savepoint is retained after rollback; nested work releases
-     * normally, so a large canonicalisation run cannot retain one subtransaction
-     * per expression.
-     * Rollback here is cleanup of dbsp-created work, not a sandbox for arbitrary
-     * session effects.
-     */
-    withScratchScope<T>(fn: (adapter: RollbackOnlyPgsqlScope<DB>) => Promise<T>): Promise<T>;
-    private createManagedClientAdapter;
-    private createPinnedConnectionAdapter;
-    private createChildTransactionObserver;
-    private observeChildTransaction;
-    private markChildTransactionObserved;
-    private refreshScopeChildrenFailure;
-    private transactionWithManagedClient;
-    private transactionWithManagedClientSavepointScope;
-    private applyTransactionTimeouts;
-    private captureAndApplySavepointTimeouts;
-    private restoreSavepointTimeouts;
-    private transactionWithClientTransaction;
-    private releaseClient;
-    private rollbackAndReleaseSavepoint;
-    private rollbackSavepoint;
-    private releaseSavepoint;
-    private rollbackTransactionIfOpen;
-    private classifyTransactionStateError;
-    private probeTransactionState;
-    private classifySavepointReleaseFailure;
-    private rollbackSavepointAfterReleaseFailure;
-    private enterTransactionScope;
-    private enterPinnedConnectionScope;
-    private enterSavepointScope;
-    private pushClientScope;
-    private currentClientScope;
-    private managedScopeEndedMessage;
-    private assertCanUseClient;
-    private assertUsableScopeAncestors;
-    private findClientScope;
-    private assertScopeNotPoisoned;
-    private throwIfScopePoisoned;
-    private scopePoisonOutranksError;
-    private poisonScopeState;
-    private poisonClientScope;
-    private poisonClientScopeStack;
-    private runWithScopeStatementLock;
-    private closeScope;
-    private closeScopeAndAssertChildren;
-    private drainScopeStatements;
-    private drainScopeChildren;
-    private assertScopeChildrenSettled;
-    private drainScopeWork;
-    private executeScopeBoundaryStatement;
-    private assertCommitSucceeded;
-    /**
-     * Create a schema-scoped adapter for multi-tenant queries.
-     */
-    withSchema(schemaName: string): Adapter<DB>;
-    /**
-     * Execute raw SQL directly.
-     *
-     * ⚠️  WARNING: Use parameter placeholders ($1, $2, etc.) for all values.
-     *
-     * Transaction control through raw SQL inside a scope dbsp is managing is
-     * unsupported. `COMMIT`, `ROLLBACK`, and `PREPARE TRANSACTION` end the
-     * transaction dbsp is working inside; dbsp detects that and fails loudly, but
-     * the data is already whatever your statement made it. Raw savepoint control
-     * (`SAVEPOINT`, `RELEASE SAVEPOINT`, `ROLLBACK TO SAVEPOINT`) can alter the
-     * savepoint stack before dbsp sees the command tag; dbsp poisons the scope, but
-     * it cannot make that command un-run. Manage your transaction outside dbsp's
-     * calls.
-     */
-    executeRaw<T = unknown>(sql: string, parameters?: readonly unknown[]): Promise<T[]>;
-    /**
-     * Generate DDL statements from a ModelIR schema.
-     *
-     * Uses PostgreSQL AST nodes and pgsql-deparser for consistent SQL generation.
-     * Applies the naming plugin for identifier transformation.
-     *
-     * @param schema - The ModelIR schema to generate DDL from
-     * @param overrideOptions - Optional overrides for DDL generation (e.g., includeDropStatements)
-     * @returns Array of DDL statements in dependency order
-     */
-    generateDDL(schema: ModelIR, overrideOptions?: Partial<GenerateDDLOptions>): string[];
-    /**
-     * Execute a DDL statement directly (e.g. TRUNCATE, VACUUM, ALTER TABLE, CREATE INDEX).
-     *
-     * @throws Error if called on a compile-only adapter (no pool)
-     * @since DDL-TABLE-001
-     */
-    executeDDL(sql: string): Promise<void>;
-    /**
-     * Whether a transaction is open on this adapter's connection.
-     * This is true for dbsp-managed scopes and for borrowed pg clients whose
-     * ReadyForQuery status says the caller has an open transaction.
-     *
-     * @since DDL-TABLE-001
-     */
-    get inTransaction(): boolean;
-    private adapterManagedScopeIsLive;
-    private shouldProtectBorrowedClientTransaction;
-    /**
-     * An idle ReadyForQuery status says nothing about commands another owner has
-     * already queued on a PoolClient. Only a dbsp-created pinned scope both owns
-     * the checked-out physical client and holds its statement lock across the
-     * failed named execution and any unnamed replay.
-     */
-    private ownsSerializedClientForPreparedStatementReplay;
-    private executeQueryProtectingOpenTransaction;
-    private executeConnectionStatement;
-    private executeConnectionStatementUnlocked;
-    private executeConnectionStatementInSavepoint;
-    private issueConnectionQuery;
-    private assertNoMultiCommandRawCall;
-    private assertNoTransactionControlCommand;
-    private assertPrepareDidNotEndTransaction;
-    /**
-     * Resolve the explicit schema for a catalog read: an explicit argument, else
-     * the adapter's configured schema, else `undefined` (resolve in-query). NOT a
-     * hard-coded 'public' — an unresolved schema is handled by the SQL, which
-     * finds the table's schema search_path-aware, in the SAME session, so a
-     * non-public search_path and a pooled connection both stay correct.
-     */
-    private explicitSchema;
-    /**
-     * List all indexes on a table by querying pg_indexes.
-     *
-     * @param table - Table name
-     * @param schema - Schema name (defaults to the search_path-resolved schema)
-     */
-    listIndexes(table: string, schema?: string, options?: {
-        namePattern?: string;
-    }): Promise<IndexInfo[]>;
-    /**
-     * Check whether an index with the given name exists on a table.
-     *
-     * @param name - Index name
-     * @param table - Table name
-     * @param schema - Schema name (defaults to the search_path-resolved schema)
-     */
-    indexExists(name: string, table: string, schema?: string): Promise<boolean>;
-    /**
-     * Return the total storage size of a table in bytes (includes indexes and TOAST).
-     *
-     * The table name is a SQL identifier — it is double-quoted, not parameterized,
-     * because PostgreSQL does not allow parameterized table names in FROM clauses.
-     * With no known schema the table is left unqualified so ::regclass resolves it
-     * through search_path (the same table an unqualified reference would hit).
-     *
-     * @param table - Table name
-     * @param schema - Schema name (defaults to the search_path-resolved schema)
-     */
-    storageSize(table: string, schema?: string): Promise<number>;
-    /**
-     * Generate SQL for TRUNCATE TABLE.
-     * Implements TableDDLGeneratorAdapter.generateTruncate.
-     */
-    generateTruncate(table: string, schemaName: string, options?: TruncateOptions): string;
-    /**
-     * Generate SQL for VACUUM.
-     * Implements TableDDLGeneratorAdapter.generateVacuum.
-     */
-    generateVacuum(table: string, schemaName: string, options?: VacuumOptions): string;
-    /**
-     * Generate SQL for ALTER TABLE ... ALTER COLUMN.
-     * Implements TableDDLGeneratorAdapter.generateAlterColumn.
-     */
-    generateAlterColumn(table: string, schemaName: string, column: string, options: AlterColumnOptions): string;
-    /**
-     * Generate SQL for CREATE INDEX.
-     * Implements TableDDLGeneratorAdapter.generateCreateIndex.
-     */
-    generateCreateIndex(table: string, schemaName: string, options: CreateIndexOptions): string;
-    /**
-     * Generate SQL for DROP INDEX.
-     * Implements TableDDLGeneratorAdapter.generateDropIndex.
-     */
-    generateDropIndex(name: string, schemaName: string, options?: DropIndexOptions): string;
-    /**
-     * Validate an identifier (table name, column name, schema name).
-     */
-    validateIdentifier(value: string, type: string): void;
-}
-/**
- * Create a PgsqlAdapter from a pg Pool instance.
- *
- * @param pool - pg Pool instance
- * @param options - Optional configuration
- * @returns A new PgsqlAdapter instance
- *
- * @example
- * ```typescript
- * import { Pool } from 'pg';
- * import { createPgsqlAdapter } from '@dbsp/adapter-pgsql';
- *
- * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
- * const adapter = createPgsqlAdapter(pool);
- *
- * // With naming convention
- * const adapter = createPgsqlAdapter(pool, { dbCasing: 'snake_case' });
- * ```
- */
-declare function createPgsqlAdapter<DB = unknown>(pool: Pool, options?: PgsqlPoolAdapterOptions): PgsqlAdapter<DB>;
-declare function createPgsqlAdapter<DB = unknown>(client: PoolClient, options: PgsqlBorrowedClientAdapterOptions): PgsqlAdapter<DB>;
-/**
- * Creates a connectionless PgsqlAdapter for SQL generation without a database connection.
- *
- * All compilation methods (compile, compileInsert, etc.), createDump(), and generateDDL()
- * work normally. The adapter has the full PgsqlAdapter surface; database operations refuse
- * at runtime until it is constructed with a connection via createPgsqlAdapter(pool).
- *
- * @example
- * ```typescript
- * import { createPgsqlCompileOnlyAdapter } from '@dbsp/adapter-pgsql';
- * import { createOrm } from '@dbsp/core';
- *
- * const adapter = createPgsqlCompileOnlyAdapter();
- * const orm = createOrm({ model, adapter });
- * const dump = await orm.select('users').dump();
- * console.log(dump.sql);
- * ```
- */
-declare function createPgsqlCompileOnlyAdapter<DB = unknown>(options?: PgsqlCompileOnlyAdapterOptions): PgsqlAdapter<DB>;
-
-interface CheckConstraintCanonicalizationWarning {
-    readonly table: string;
-    readonly kind: 'check_constraint';
-    readonly name: string;
-    readonly constraint: string;
-    readonly message: string;
-    readonly cause: unknown;
-}
-interface ColumnDefaultCanonicalizationWarning {
-    readonly table: string;
-    readonly kind: 'column_default';
-    readonly name: string;
-    readonly message: string;
-    readonly cause: unknown;
-    readonly outcome?: 'unavailable' | 'rejected' | 'refused';
-    /** Whether this warning represents a raw fallback or absent counterpart. */
-    readonly comparison: 'raw' | 'unpaired';
-    /** Present when the default could not be paired with the opposite model side. */
-    readonly side?: 'desired' | 'database';
-}
-interface IndexPredicateCanonicalizationWarning {
-    readonly table: string;
-    readonly kind: 'index_predicate';
-    readonly name: string;
-    readonly message: string;
-    readonly cause: unknown;
-    readonly outcome: 'unavailable' | 'rejected' | 'refused';
-    /** Predicate fallback always compares both complete models raw. */
-    readonly comparison: 'raw';
-    readonly side?: 'desired' | 'database';
-}
-type ExpressionCanonicalizationWarning = CheckConstraintCanonicalizationWarning | ColumnDefaultCanonicalizationWarning | IndexPredicateCanonicalizationWarning;
-interface CanonicalizeCheckConstraintsOptions {
-    /** Database schema that owns the target tables and target-scoped enum types. */
-    readonly schemaName?: string;
-    /** Naming convention used when matching desired table names to DB table names. */
-    readonly dbCasing?: DbCasing;
-    /** Called when PostgreSQL CHECK canonicalisation fails and raw comparison is used. */
-    readonly onWarning?: (warning: CheckConstraintCanonicalizationWarning) => void;
-    /** Throw instead of falling back to raw comparison when canonicalisation fails. */
-    readonly requireCanonicalization?: boolean;
-    /** Skip CHECK scratch work when the caller's dialect does not support CHECK DDL. */
-    readonly canonicalizeCheckConstraints?: boolean;
-    /** Capabilities used to generate the migration this scope is staging for. */
-    readonly dialectCapabilities?: DialectCapabilities;
-}
-declare class CheckConstraintCanonicalizationError extends Error {
-    readonly table: string;
-    readonly constraints: readonly string[];
-    readonly cause: unknown;
-    constructor(table: string, constraints: readonly string[], cause: unknown);
-}
-declare class ColumnDefaultCanonicalizationError extends Error {
-    readonly table: string;
-    readonly column: string;
-    readonly cause: unknown;
-    constructor(table: string, column: string, cause: unknown);
-}
-/**
- * Canonicalise PostgreSQL CHECK constraint expressions in a desired model.
- */
-declare function canonicalizeCheckConstraints(adapter: RollbackOnlyPgsqlScope, desired: ModelIR, dbModel: ModelIR, options?: CanonicalizeCheckConstraintsOptions): Promise<ModelIR>;
-
-interface ComparePgsqlDatabaseSchemaOptions extends CompareSchemataOptions, SchemaScopeOptions {
-    /**
-     * Whether to canonicalise PostgreSQL CHECK constraint expressions, column defaults, and predicates on column-keyed
-     * partial indexes before comparing. Defaults to `true`. Expression-keyed
-     * partial-index predicates are reported as unavailable. Set to `false` only for compatibility with
-     * legacy raw-string live diffs.
-     *
-     * Live canonicalisation creates temporary scratch tables inside an adapter
-     * scratch scope whose successful cleanup is rollback. The database role needs
-     * permission to create temporary tables and use the scratch column types. If
-     * PostgreSQL refuses that scratch DDL, non-strict mode warns and falls back to
-     * best-effort raw string comparison for the affected expression surfaces.
-     */
-    readonly canonicalizeExpressions?: boolean;
-    /**
-     * Receives live expression canonicalisation warnings. Defaults to console.warn.
-     */
-    readonly onWarning?: (message: string) => void;
-    /** Receives the identity-bearing canonicalisation warning before its string form. */
-    readonly onExpressionCanonicalizationWarning?: (warning: ExpressionCanonicalizationWarning) => void;
-    /**
-     * Diff that the caller just applied before this live re-diff. Used only when
-     * expression surfaces are compared by raw text to fail loudly if the exact same
-     * expression-surface drift appears again after re-introspection.
-     */
-    readonly previouslyAppliedDiff?: SchemaDiff;
-}
-type NonConvergentSchemaDiffSurface = {
-    readonly kind: 'check_constraint';
-    readonly table: string;
-    readonly constraint: string;
-} | {
-    readonly kind: 'column_default';
-    readonly table: string;
-    readonly column: string;
-};
-declare class NonConvergentSchemaDiffError extends Error {
-    readonly surface: NonConvergentSchemaDiffSurface;
-    readonly desiredExpressionHash: string;
-    readonly databaseExpressionHash: string;
-    constructor(surface: NonConvergentSchemaDiffSurface, desiredExpressionHash: string, databaseExpressionHash: string);
-}
-/** An enum value this diff adds, reported as a candidate cause — never asserted. */
-interface AddedEnumValue {
-    readonly enumName: string;
-    readonly value: string;
-}
-declare class CheckConstraintNewEnumValueError extends Error {
-    readonly table: string;
-    readonly constraint: string;
-    readonly addedEnumValues: readonly AddedEnumValue[];
-    constructor(table: string, constraint: string, addedEnumValues: readonly AddedEnumValue[]);
-}
-/** A raw partial-index predicate and added enum values cannot share one migration. */
-declare class PartialIndexPredicateNewEnumValueError extends Error {
-    readonly addedEnumValues: readonly AddedEnumValue[];
-    constructor(addedEnumValues: readonly AddedEnumValue[]);
-}
-/** #454: Predicate canonicalization is not implemented for indexes with expression keys. */
-declare class ExpressionKeyedIndexPredicateCanonicalizationUnsupportedError extends Error {
-    readonly predicates: readonly {
-        readonly side: 'desired' | 'database';
-        readonly table: string;
-        readonly index: string;
-    }[];
-    constructor(predicates: readonly {
-        readonly side: 'desired' | 'database';
-        readonly table: string;
-        readonly index: string;
-    }[]);
-}
-/**
- * A raw partial-index predicate cannot be proven to converge after PostgreSQL
- * deparses it, so emitting its CREATE statement is unsafe.
- */
-declare class RawIndexPredicateFallbackError extends Error {
-    constructor(cause?: unknown);
-}
-declare class IndexPredicateCanonicalizationError extends Error {
-    readonly rejectedPredicates: readonly {
-        readonly side: 'desired' | 'database';
-        readonly table: string;
-        readonly index: string;
-        readonly reason?: unknown;
-    }[];
-    /**
-     * Enum values added by this migration are diagnostic candidates only. They
-     * are collected from the schema diff, never matched to a rejected index.
-     */
-    readonly addedEnumValues: readonly AddedEnumValue[];
-    constructor(rejectedPredicates: readonly {
-        readonly side: 'desired' | 'database';
-        readonly table: string;
-        readonly index: string;
-        readonly reason?: unknown;
-    }[], 
-    /**
-     * Enum values added by this migration are diagnostic candidates only. They
-     * are collected from the schema diff, never matched to a rejected index.
-     */
-    addedEnumValues?: readonly AddedEnumValue[]);
-}
-/**
- * Live PostgreSQL schema diff: introspect, canonicalise desired CHECK
- * constraint expressions, column defaults, and predicates on column-keyed
- * partial indexes through PostgreSQL, then call the pure synchronous
- * schema comparator.
- *
- * If CHECK canonicalisation falls back while the same diff adds a plausibly
- * referenced enum value, the diff is refused. dbsp currently applies each
- * migration in one transaction, and PostgreSQL forbids using a newly added enum
- * value in that same transaction; emitting the CHECK would produce a migration
- * that cannot run. Apply the enum addition by itself first, then add or update
- * the CHECK constraint in a later migration.
- *
- * Index expressions are intentionally not canonicalised here; partial-index
- * predicates on expression-keyed indexes are reported as unavailable and are
- * therefore rejected by strict mode. They need their own key-shape substrate.
- */
-declare function comparePgsqlDatabaseSchema(adapter: PgsqlAdapter, desired: ModelIR, options?: ComparePgsqlDatabaseSchemaOptions): Promise<SchemaDiff>;
-declare function assertNoRepeatedExpressionSurfaceDrift(previouslyAppliedDiff: SchemaDiff, currentDiff: SchemaDiff, rawExpressionSurfaces?: ReadonlySet<string>): void;
-
-/**
- * Migration SQL Generator (DDL-PROV Block 1)
- *
- * Generates ordered SQL statements from a SchemaDiff.
- * Statements are topologically sorted: DROP constraints → DROP objects → CREATE objects → ADD constraints.
- *
- * @module migration-sql
- */
-
-interface MigrationSQLOptions {
-    /**
-     * Schema namespace (default: none — unqualified).
-     * Required when emitted migration SQL would otherwise mix non-default
-     * target-scoped custom types/enums with unqualified table SQL.
-     */
-    readonly schemaName?: string;
-    /** Whether to include destructive changes (drops) */
-    readonly includeDestructive?: boolean;
-    /** Automatically create indexes on FK columns for new tables (default: true) */
-    readonly fkAutoIndex?: boolean;
-    /** Dialect capabilities — unsupported index features throw during migration SQL generation */
-    readonly dialectCapabilities?: DialectCapabilities;
-}
-/**
- * Generate ordered SQL statements from a SchemaDiff.
- *
- * Topological order:
- * 0.  DROP FK/CHECK constraints (must drop before referenced tables)
- * 1.  DROP indexes
- * 2.  DROP columns
- * 3.  DROP primary keys
- * 4.  DROP tables, DROP ENUMs
- * 5.  CREATE ENUMs (must exist before tables that use them)
- * 6.  CREATE tables
- * 7.  ADD columns
- * 8.  ALTER columns (type, nullable, default)
- * 9.  ADD primary keys / column UNIQUE constraints
- * 10. ADD FK constraints (must add after referenced tables exist)
- * 11. ALTER FK (drop + re-add)
- * 12. CREATE indexes
- * 13. ADD CHECK constraints
- * 14. ALTER ENUM ADD VALUE (must be last — has transaction visibility caveats in PG)
- * 15. COMMENT ON TABLE / COLUMN (very last)
- */
-declare function generateMigrationSQL(diff: SchemaDiff, options?: MigrationSQLOptions): readonly string[];
-/**
- * Generate ordered DOWN SQL statements from a SchemaDiff.
- *
- * Reverses the topological order used in UP migrations:
- * phases run in descending order (11, 10, 9, ..., 0).
- *
- * Irreversible changes (drops that lose data) produce SQL WARNING comments.
- */
-declare function generateDownSQL(diff: SchemaDiff, options?: MigrationSQLOptions): readonly string[];
+declare function readGeneratedPostcondition(executor: GeneratedPostconditionSession, step: NormalizedManagedStep, address: LedgerAddress): Promise<GeneratedPostconditionObservation>;
 
 /**
  * Type Mapping - Maps ModelIR ColumnType to PostgreSQL data types
@@ -2510,28 +1397,6 @@ declare const DEFAULT_REDACTION_PATTERNS: ReadonlyArray<RegExp>;
  */
 declare function redactParams(params: readonly unknown[], config: RedactionConfig): readonly unknown[];
 
-declare const projectionEnvelopeBrand: unique symbol;
-type ProjectionEnvelope<T = unknown> = {
-    readonly [projectionEnvelopeBrand]: true;
-    readonly sql: string;
-    readonly parameters: readonly unknown[];
-    readonly ast?: Node;
-    readonly projection: ProjectionState;
-    readonly hydrationPlan?: PlanReport;
-    readonly __resultType?: T;
-};
-type ProjectionState = {
-    readonly kind: 'known';
-    readonly outputs: ReadonlyMap<string, OutputProjection>;
-} | {
-    readonly kind: 'dropped';
-    readonly reason: ProjectionDropReason;
-    readonly hadConvertibleSource: boolean;
-};
-type OutputProjection = OutputDescriptor;
-
-type ProjectionDropReason = 'set-operation-positional-merge' | 'raw-recursive-cte-positional-merge' | 'unknown-raw-sql' | 'unsupported-source';
-
 /**
  * Set operation compiler (UNION / INTERSECT / EXCEPT)
  *
@@ -3292,10 +2157,7 @@ interface SetNotNullMatch {
     readonly expectedColumnShape: SetNotNullColumnShapeExpectation;
     readonly assumptions?: readonly Assumption[];
 }
-interface SetNotNullRuleOptions {
-    readonly naming?: NamingPlugin;
-}
-declare function createSetNotNullRule(options?: SetNotNullRuleOptions): TransitionRule<SetNotNullMatch>;
+declare function createSetNotNullRule(): TransitionRule<SetNotNullMatch>;
 
 interface EnumAddValueMatch {
     readonly schema?: string;
@@ -3308,6 +2170,9 @@ interface EnumAddValueMatch {
     readonly assumptions?: readonly Assumption[];
 }
 interface EnumAddValueRuleOptions {
+    /**
+     * @deprecated Ignored because declared enum names are physical identifiers (#825).
+     */
     readonly naming?: NamingPlugin;
 }
 declare function satisfiesPgEnumLabelVisibleCompositionFact(fact: TransitionCompositionFact, current: ModelIR, _context: ObservationContext): boolean;
@@ -3336,7 +2201,6 @@ interface LogicalIdentityAdoptionMatch {
     readonly selectionBasis: string;
 }
 interface LogicalIdentityAdoptionRuleOptions {
-    readonly naming?: NamingPlugin;
     readonly asserter?: IdentityAdoptionAsserter;
     readonly selectionBasis?: string;
 }
@@ -3353,8 +2217,6 @@ interface AddCheckMatch {
 }
 
 interface PgTransitionPackOptions {
-    readonly dbCasing?: DbCasing;
-    readonly naming?: NamingPlugin;
     readonly identityAdoptionAsserter?: IdentityAdoptionAsserter;
     readonly identityAdoptionSelectionBasis?: string;
 }
@@ -3868,12 +2730,93 @@ declare function readPgRemovalEffectsClosure(input: {
     readonly isManaged: (address: LedgerAddress) => Promise<boolean>;
 }): Promise<PgRemovalEffectsClosure>;
 
+interface ConvergePgBaseOptions extends Omit<ConvergePgOptions$1, 'schema' | 'dbCasing' | 'mode' | 'declaredSequenceNames' | 'fkAutoIndex'> {
+}
+interface ConvergePgOptions extends ConvergePgBaseOptions {
+    readonly mode?: 'apply';
+}
+interface ConvergePgCheckOptions extends ConvergePgBaseOptions {
+    readonly mode: 'check';
+}
+declare function convergePg(pool: Pool, physical: PgPhysicalModel, options?: ConvergePgOptions): Promise<PgConvergeResult>;
+declare function convergePg(pool: Pool, physical: PgPhysicalModel, options: ConvergePgCheckOptions): Promise<PgConvergeCheckResult>;
+
+type PgReconcileRecoveryOutcome = 'appended' | 'already-appended' | 'indeterminate-appended' | 'no-open-claim' | 'pending' | 'blocked' | 'malformed-chain' | 'protocol-refused' | 'transport-ambiguous' | 'refused-pair' | 'indeterminate-pair';
+type PgReconcileRecoveryFailureCause = 'catalogue' | 'malformed-journal' | 'transport';
+/** One ordered recovery attempt; diagnostics are raw and presentation-free. */
+interface PgReconcileRecoveryReport {
+    readonly address: LedgerAddress;
+    readonly outcome: PgReconcileRecoveryOutcome;
+    readonly reason?: string;
+    readonly pairId?: string;
+    readonly failureCause?: PgReconcileRecoveryFailureCause;
+}
+/** The selected semantic refusal condition, never a CLI refusal document. */
+type PgReconcileSelectedIssue = {
+    readonly kind: 'ledger-not-current';
+    readonly currency: Exclude<PgLedgerScopeCurrency, {
+        readonly kind: 'current';
+    }>;
+    readonly affectedAddresses: readonly LedgerAddress[];
+} | {
+    readonly kind: 'database-read-only';
+    readonly reason: string;
+    readonly affectedAddresses: readonly LedgerAddress[];
+} | {
+    readonly kind: 'catalogue-unavailable';
+    readonly address: LedgerAddress;
+} | {
+    readonly kind: 'malformed-chain';
+    readonly address: LedgerAddress;
+};
+interface PgReconcileBaseResult {
+    readonly runId: string;
+    readonly addresses: readonly ResourceAddress[];
+    readonly recovery?: readonly PgReconcileRecoveryReport[];
+    readonly selectedIssue?: PgReconcileSelectedIssue;
+}
+type PgReconcileTransitionRunResult = (PgReconcileBaseResult & {
+    readonly kind: 'completed';
+}) | (PgReconcileBaseResult & {
+    readonly kind: 'unresolved';
+}) | (PgReconcileBaseResult & {
+    readonly kind: 'selection-unavailable';
+    readonly detail?: string;
+}) | (PgReconcileBaseResult & {
+    readonly kind: 'database-read-only';
+    readonly selectedIssue: Extract<PgReconcileSelectedIssue, {
+        readonly kind: 'database-read-only';
+    }>;
+}) | {
+    readonly kind: 'busy';
+    readonly runId: string;
+    readonly addresses: readonly ResourceAddress[];
+};
+type PgReconcileFailureStage = 'reconcile' | 'journal' | 'catalogue';
+/** A read/recovery failure whose original cause remains available to callers. */
+declare class PgReconcileTransitionRunError extends Error {
+    readonly stage: PgReconcileFailureStage;
+    readonly originalCause: unknown;
+    constructor(stage: PgReconcileFailureStage, originalCause: unknown);
+}
+/**
+ * Returns recovery decisions for one durable run without reissuing DDL.
+ *
+ * Reconciliation keeps the run-lock session while `recoverPgOutcomeClaim`
+ * acquires its own outcome session. The supplied pool must allow at least two
+ * concurrent connections: a pool with `max: 1` waits forever under the lock.
+ */
+declare function reconcilePgTransitionRun(pool: Pool, runId: string): Promise<PgReconcileTransitionRunResult>;
+/** Finds every execution id durably attributable to one transition run. */
+declare function executionIdsForRun(journal: Awaited<ReturnType<typeof readTransitionJournal>>): readonly string[];
+
 /**
  * Identifier Validation for adapter-pgsql
  *
  * Security layer to prevent SQL injection via identifiers.
  * All table names, column names, schema names, and aliases MUST pass validation.
  */
+
 /**
  * Error thrown when an identifier fails validation.
  */
@@ -3926,11 +2869,6 @@ declare function validateIdentifiers(identifiers: Record<string, 'table' | 'colu
  * NOT for use in SQL - use validateIdentifier + AST helpers for that.
  */
 declare function sanitizeForDisplay(value: string): string;
-/**
- * Preserve hostile diagnostic text as one printable line without losing which
- * control character was supplied. This is for diagnostics only, never SQL.
- */
-declare function escapeDiagnosticText(value: string): string;
 /**
  * Validate a raw SQL expression used in DDL contexts (defaults, policy USING/CHECK).
  * Rejects injection vectors: semicolons, line-comment markers, block-comment markers.
@@ -3942,4 +2880,4 @@ declare function escapeDiagnosticText(value: string): string;
  */
 declare function validateSqlExpression(sql: string, context: string): void;
 
-export { ADD_CHECK_RULE_ID, ALTER_AUTHORITY_OBSERVATION, ALTER_COLUMN_SET_NOT_NULL_OPERATION_KIND, ALTER_TYPE_ADD_VALUE_OPERATION_KIND, ATTACH_LOGICAL_IDENTITY_OPERATION_KIND, type AddedEnumValue, type AlterColumnSetNotNullPayload, type AlterTypeAddValuePayload, type AttachLogicalIdentityPayload, type BatchValuesJoinDecision, COLUMN_EXISTS_OBSERVATION, CamelCaseNamingPlugin, type CanonicalizeCheckConstraintsOptions, ChangeKind, CheckConstraintCanonicalizationError, type CheckConstraintCanonicalizationWarning, CheckConstraintNewEnumValueError, ColumnDefaultCanonicalizationError, type ColumnDefaultCanonicalizationWarning, type ComparePgsqlDatabaseSchemaOptions, CompareSchemataOptions, type CompiledResult, type CompilerContext, type CompilerOptions, type CompilerState, type ConflictAction, type ConflictTarget, type CursorHoldOption, type CursorOptions, type CursorScrollOption, DATABASE_READ_ONLY_OUTCOME, DBSP_LEDGER_EVENT_TABLE, DBSP_LEDGER_IDENTITY_TABLE, DBSP_LEDGER_MARKER_TABLE, DBSP_LEDGER_RESERVATION_TABLE, DBSP_LOGICAL_IDENTITY_TABLE, DBSP_META_SCHEMA, DBSP_TRANSITION_AUTHORIZATION_TABLE, DBSP_TRANSITION_JOURNAL_TABLE, DBSP_TRANSITION_RUN_PLAN_TABLE, DBSP_TRANSITION_RUN_TABLE, DEFAULT_PK_COLUMN, DEFAULT_REDACTION_PATTERNS, type Decision, type DeleteConfig, type DetectedHierarchy, ENGINE_VERSION_OBSERVATION, ENUM_ADD_VALUE_RULE_ID, ENUM_LABEL_VISIBLE_OBSERVATION, ENUM_TYPE_EXISTS_OBSERVATION, type EnumAddValueMatch, type EnumAddValueRuleOptions, type ExplainFormat, type ExplainOptions, type ExplainPlan, type ExpressionCanonicalizationWarning, type ExpressionHandler, ExpressionKeyedIndexPredicateCanonicalizationUnsupportedError, type FetchDirection, type FetchOptions, type FkColumnDerivation, type GenerateDDLOptions, type GeneratedMutationClassification, type IdentityAdoptionAsserter, IdentityNamingPlugin, type IncludeHandler, type IncludeResult, type IndexCapabilityContext, IndexFeatureUnsupportedError, IndexPredicateCanonicalizationError, type IndexRenderSpec, type InsertConfig, type IntrospectedModelIR, type IntrospectionOptions, InvalidIdentifierError, type JoinDecision, LOGICAL_IDENTITY_ADOPTION_RULE_ID, LOGICAL_IDENTITY_CARRIER_OBSERVATION, type LeafCompileFn, type LogicalIdentityAdoptionMatch, type LogicalIdentityAdoptionRuleOptions, MANUAL_SQL_OPERATION_KIND, type ManualSqlPayload, type MigrationSQLOptions, NO_NULLS_GUARD, type NamingPlugin, NonConvergentSchemaDiffError, type NonConvergentSchemaDiffSurface, PG_INTROSPECTION_ARTIFACT, PG_OPERATION_PACK_ARTIFACT, PG_RULE_PACK_ARTIFACT, type ParamRefValidationResult, PartialIndexPredicateNewEnumValueError, type PgAdoptionPreflightResult, type PgAdoptionResult, type PgAdvisoryLockKey, type PgAdvisoryLockResult, PgDatabaseReadOnlyError, type PgDatabaseWritability, type PgDeclaredAdoptionInput, PgExecutionContractDerivationError, type PgLedgerAddressChain, PgLockedRun, PgOutcomeCheckpointObserver, type PgPersistedDeclaredAdoptionInput, type PgPersistedReaddressInput, type PgReaddressPairRecoveryResult, type PgReleaseResult, type PgRemovalEffectAddress, type PgRemovalEffectsClosure, type PgTransitionClientLease, type PgTransitionPackOptions, PgsqlAdapter, type PgsqlAdapterOptions, PgsqlAdvisoryLockOptionsError, type PgsqlBorrowedClientAdapterOptions, type PgsqlCompileOnlyAdapterOptions, PgsqlPinnedConnectionAbortSignalError, type PgsqlPoolAdapterOptions, PgsqlPreparedStatementReplayError, type PgsqlPreparedStatementsOptions, PgsqlRawSqlTransactionControlError, PgsqlTransactionAbortSignalError, PgsqlTransactionAbortedCommitError, PgsqlTransactionAbortedError, PgsqlTransactionOptionsError, PgsqlTransactionTimeoutError, PlanCompiler, type PlanDecision, type PrecompiledJoinDecision, RawIndexPredicateFallbackError, type RedactionConfig, type RedactionPattern, type RollbackOnlyPgsqlScope, SET_NOT_NULL_RULE_ID, SchemaDiff, type SchemaScopeOptions, type SetNotNullMatch, type SetNotNullRuleOptions, type SetOperationResult, type SimplifiedPlanReport, type StreamConfig, type UpdateConfig, type UpsertConfig, type WhereDispatcher, type WhereHandler, acquirePgTransitionClient, assertCreateIndexSupported, assertCreateIndexesSupported, assertCreateUniqueIndexConcurrentlyRecoveryNotInvalid, assertNoRepeatedExpressionSurfaceDrift, assertPgDatabaseWritable, bm25Search, booleanSearch, boost, buildCloseCursor, buildDeclareCursor, buildExplain, buildExplainAnalyzeJson, buildExplainPlan, buildExplainVerbose, buildFetch, buildFetchAll, buildFetchFirst, buildFetchForward, buildFetchNext, buildOnConflictClause, buildStreamingStatements, camelCaseNaming, canGenerateCreateIndex, canonicalizeCheckConstraints, classifyGeneratedMutation, classifyPgDatabaseWritability, classifyPgReaddressRecovery, classifyPgReaddressSupport, classifyPgWrite, classifyRemovalEffectsClosure, collectAndValidateParamRefs, comparePgsqlDatabaseSchema, compileDelete, compileInsert, compileMutation, compilePlan, compileSetOperation, compileUpdate, compileUpsert, conditionalUpdate, containmentAuthorityOutcome, cosineDistance, createAlterColumnSetNotNullOperationRuntime, createAlterTypeAddValueOperationRuntime, createAnyExpr, createAttachLogicalIdentityOperationRuntime, createEnumAddValueRule, createEqualityExpr, createLeafCompileFn, createLogicalIdentityAdoptionRule, createManualSqlOperationRuntime, createParamRef, createPgExecutionContract, createPgObservationIssuer, createPgTransitionLessor, createPgTransitionPack, createPgsqlAdapter, createPgsqlCompileOnlyAdapter, createSetNotNullRule, createTypeCastParamRef, dbTypesEqual, defaultFkDerivation, derivePostgresqlCapabilitiesForVersion, escapeDiagnosticText, evaluatePgExecutionContract, excludedRef, executePgDeclaredAdoption, executePgObservationFromLessor, executePgPersistedTableReaddress, findPgLedgerTerminalMember, generateCreateIndex, generateCursorName, generateDDL, generateDownSQL, generateMigrationSQL, generateSeries, getNamingPluginForDbCasing, getRowEstimates, getTotalExecutionTime, identityNaming, innerProduct, introspect, isBatchValuesJoinDecision, isGeneratedMutationDestructive, isJoinDecision, isPgDatabaseReadOnlyError, isPrecompiledJoinDecision, isReservedKeyword, l2Distance, mapColumnType, mapOnDeleteAction, nextval, normalizeManualSqlPayload, parse, parseExplainJson, pgTargetIdentityMismatch, preflightPgDeclaredAdoption, preparePgExecutionSession, preparePgRecoveryAdmission, rawDistance, readPgExecutionTargetFromClient, readPgLedgerAddressChain, readPgLedgerControllerOid, readPgObservationContextFromClient, readPgObservationContextFromLessor, readPgRemovalEffectsClosure, recoverPgReaddressPair, redactParams, refusesRecordedPlanRemoval, releasePgManagedAddress, renderAlterColumnSetNotNullSql, renderAlterTypeAddValueSql, renderAttachLogicalIdentityLockSql, renderCreateIndex, renderCreateLogicalIdentityIndexesSql, renderCreateLogicalIdentitySideTableSql, renderInsertLogicalIdentitySql, renderNoNullsCheckSql, renderPgTableReaddressStatements, renderSetNotNullLockSql, reservationsForRemovalClosure, resolveLogicalName, sanitizeForDisplay, score, validateIdentifier, validateIdentifiers, validateParamRef, validatePgManagedLedgerCurrency, validateQualifiedIdentifier, validateSqlExpression, vectorDims, withPgTransitionRunLock };
+export { ADD_CHECK_RULE_ID, ALTER_AUTHORITY_OBSERVATION, ALTER_COLUMN_SET_NOT_NULL_OPERATION_KIND, ALTER_TYPE_ADD_VALUE_OPERATION_KIND, ATTACH_LOGICAL_IDENTITY_OPERATION_KIND, type AlterColumnSetNotNullPayload, type AlterTypeAddValuePayload, type AttachLogicalIdentityPayload, type BatchValuesJoinDecision, COLUMN_EXISTS_OBSERVATION, ChangeKind, type CompiledResult, type CompilerContext, type CompilerOptions, type CompilerState, type ConflictAction, type ConflictTarget, type ConvergePgBaseOptions, type ConvergePgCheckOptions, type ConvergePgOptions, type CursorHoldOption, type CursorOptions, type CursorScrollOption, DATABASE_READ_ONLY_OUTCOME, DBSP_LEDGER_EVENT_TABLE, DBSP_LEDGER_IDENTITY_TABLE, DBSP_LEDGER_MARKER_TABLE, DBSP_LEDGER_RESERVATION_TABLE, DBSP_LOGICAL_IDENTITY_TABLE, DBSP_META_SCHEMA, DBSP_TRANSITION_AUTHORIZATION_TABLE, DBSP_TRANSITION_JOURNAL_TABLE, DBSP_TRANSITION_RUN_PLAN_TABLE, DBSP_TRANSITION_RUN_TABLE, DEFAULT_REDACTION_PATTERNS, type Decision, type DeleteConfig, ENGINE_VERSION_OBSERVATION, ENUM_ADD_VALUE_RULE_ID, ENUM_LABEL_VISIBLE_OBSERVATION, ENUM_TYPE_EXISTS_OBSERVATION, type EnumAddValueMatch, type EnumAddValueRuleOptions, type ExplainFormat, type ExplainOptions, type ExplainPlan, type ExpressionHandler, type FetchDirection, type FetchOptions, FkColumnDerivation, type GeneratedIdentityObservation, type GeneratedMutationClassification, type GeneratedPostconditionObservation, type GeneratedPostconditionReadBack, GeneratedPostconditionSession, type GeneratedStructuralObservation, type IdentityAdoptionAsserter, type IncludeHandler, type IncludeResult, type InsertConfig, InvalidIdentifierError, type JoinDecision, LOGICAL_IDENTITY_ADOPTION_RULE_ID, LOGICAL_IDENTITY_CARRIER_OBSERVATION, type LeafCompileFn, type LogicalIdentityAdoptionMatch, type LogicalIdentityAdoptionRuleOptions, MANUAL_SQL_OPERATION_KIND, type ManualSqlPayload, NO_NULLS_GUARD, NamingPlugin, PG_INTROSPECTION_ARTIFACT, PG_OPERATION_PACK_ARTIFACT, PG_RULE_PACK_ARTIFACT, type ParamRefValidationResult, type PgAdoptionPreflightResult, type PgAdoptionResult, PgConvergeCheckResult, PgConvergeResult, PgDatabaseReadOnlyError, type PgDatabaseWritability, type PgDeclaredAdoptionInput, PgExecutionContractDerivationError, type PgLedgerAddressChain, PgLedgerScopeCurrency, PgLockedRun, PgOutcomeCheckpointObserver, type PgPersistedDeclaredAdoptionInput, type PgPersistedReaddressInput, PgPhysicalModel, type PgReaddressPairRecoveryResult, type PgReconcileFailureStage, type PgReconcileRecoveryFailureCause, type PgReconcileRecoveryOutcome, type PgReconcileRecoveryReport, type PgReconcileSelectedIssue, PgReconcileTransitionRunError, type PgReconcileTransitionRunResult, type PgReleaseResult, type PgRemovalEffectAddress, type PgRemovalEffectsClosure, type PgTransitionClientLease, type PgTransitionPackOptions, PlanCompiler, type PlanDecision, type PrecompiledJoinDecision, type RedactionConfig, type RedactionPattern, SET_NOT_NULL_RULE_ID, type SetNotNullMatch, type SetOperationResult, type SimplifiedPlanReport, type StreamConfig, type UpdateConfig, type UpsertConfig, type WhereDispatcher, type WhereHandler, acquirePgTransitionClient, assertCreateUniqueIndexConcurrentlyRecoveryNotInvalid, assertPgDatabaseWritable, bm25Search, booleanSearch, boost, buildCloseCursor, buildDeclareCursor, buildExplain, buildExplainAnalyzeJson, buildExplainPlan, buildExplainVerbose, buildFetch, buildFetchAll, buildFetchFirst, buildFetchForward, buildFetchNext, buildOnConflictClause, buildStreamingStatements, classifyGeneratedMutation, classifyPgDatabaseWritability, classifyPgReaddressRecovery, classifyPgReaddressSupport, classifyPgWrite, classifyRemovalEffectsClosure, collectAndValidateParamRefs, compileDelete, compileInsert, compileMutation, compilePlan, compileSetOperation, compileUpdate, compileUpsert, conditionalUpdate, containmentAuthorityOutcome, convergePg, cosineDistance, createAlterColumnSetNotNullOperationRuntime, createAlterTypeAddValueOperationRuntime, createAnyExpr, createAttachLogicalIdentityOperationRuntime, createEnumAddValueRule, createEqualityExpr, createLeafCompileFn, createLogicalIdentityAdoptionRule, createManualSqlOperationRuntime, createParamRef, createPgExecutionContract, createPgObservationIssuer, createPgTransitionLessor, createPgTransitionPack, createSetNotNullRule, createTypeCastParamRef, dbTypesEqual, derivePostgresqlCapabilitiesForVersion, evaluatePgExecutionContract, excludedRef, executePgDeclaredAdoption, executePgObservationFromLessor, executePgPersistedTableReaddress, executionIdsForRun, findPgLedgerTerminalMember, generateCursorName, generateSeries, getRowEstimates, getTotalExecutionTime, innerProduct, isBatchValuesJoinDecision, isGeneratedMutationDestructive, isJoinDecision, isPgDatabaseReadOnlyError, isPrecompiledJoinDecision, isReservedKeyword, l2Distance, mapColumnType, mapOnDeleteAction, nextval, normalizeManualSqlPayload, parse, parseExplainJson, pgTargetIdentityMismatch, preflightPgDeclaredAdoption, preparePgExecutionSession, preparePgRecoveryAdmission, rawDistance, readGeneratedPostcondition, readGeneratedPostconditionReadBack, readPgExecutionTargetFromClient, readPgLedgerAddressChain, readPgLedgerControllerOid, readPgObservationContextFromClient, readPgObservationContextFromLessor, readPgRemovalEffectsClosure, readTransitionJournal, reconcilePgTransitionRun, recoverPgReaddressPair, redactParams, refusesRecordedPlanRemoval, releasePgManagedAddress, renderAlterColumnSetNotNullSql, renderAlterTypeAddValueSql, renderAttachLogicalIdentityLockSql, renderCreateLogicalIdentityIndexesSql, renderCreateLogicalIdentitySideTableSql, renderInsertLogicalIdentitySql, renderNoNullsCheckSql, renderPgTableReaddressStatements, renderSetNotNullLockSql, reservationsForRemovalClosure, resolveLogicalName, sanitizeForDisplay, score, validateIdentifier, validateIdentifiers, validateParamRef, validatePgManagedLedgerCurrency, validateQualifiedIdentifier, validateSqlExpression, vectorDims, withPgTransitionRunLock };