@dbsp/types 3.4.0 → 5.0.0

package/dist/{adapter-CjwnHeg4.d.ts → adapter-DXjfHEAf.d.ts}

@@ -202,6 +202,10 @@ interface ColumnIR {
  * Foreign key constraint
  */
 interface ForeignKeyIR {
+    /** Physical PostgreSQL constraint name when the model has been physicalized. */
+    readonly name?: string;
+    /** Physical PostgreSQL name of the automatic single-column FK index. */
+    readonly autoIndexName?: string;
     /** Local columns that form the FK */
     readonly columns: readonly string[];
     /** Referenced table and columns; schema is the referenced table's schema and defaults to the FK's own/migration schema when absent */
@@ -231,21 +235,29 @@ interface ForeignKeyIR {
 interface SequenceIR {
     /** Sequence name */
     readonly name: string;
+    /** Explicitly bring this existing standalone sequence under managed state. Adoption is never inferred. */
+    readonly adopt?: true;
     /** Start value */
-    readonly startWith?: number;
+    readonly startWith?: number | string;
     /** Increment step */
-    readonly incrementBy?: number;
+    readonly incrementBy?: number | string;
     /** Minimum value */
-    readonly minValue?: number;
+    readonly minValue?: number | string;
     /** Maximum value */
-    readonly maxValue?: number;
+    readonly maxValue?: number | string;
     /** Whether to cycle */
     readonly cycle?: boolean;
     /** Schema name (if not default) */
     readonly schema?: string;
 }
 interface EnumIR {
-    /** Enum type name */
+    /**
+     * Raw PostgreSQL catalog type name (`pg_type.typname`): no identifier
+     * quotes, schema, modifiers or array suffix. It is physical: `dbCasing`
+     * never maps it. A column refers to it through the rendered spelling in
+     * `originalDbType` (`status`, `"Status"`, `status[]`), with the schema in
+     * `originalDbTypeSchema`. Its `ModelIR.enums` key must be this same string.
+     */
     readonly name: string;
     /** Ordered list of enum values */
     readonly values: readonly string[];
@@ -254,6 +266,7 @@ interface EnumIR {
 }
 interface RequiredEnumLabelIR {
     readonly schema?: string;
+    /** Physical enum type name, as in `EnumIR.name`; `dbCasing` never maps it. */
     readonly type: string;
     readonly label: string;
 }
@@ -327,7 +340,12 @@ interface IndexIR {
     readonly nullsNotDistinct?: boolean;
     /** Index access method (default: btree) */
     readonly method?: string;
-    /** Partial index predicate (WHERE clause) */
+    /**
+     * Partial index predicate (WHERE clause). The model representation has one
+     * absence value: `undefined`. Every present string, including an empty or
+     * whitespace-only string, is an authored `WHERE` clause and must reach
+     * PostgreSQL.
+     */
     readonly where?: string;
     /** Expression-based index entries (used instead of/alongside columns) */
     readonly expressions?: readonly string[];
@@ -344,12 +362,27 @@ interface IndexIR {
 interface TableIR {
     /** Table name in database */
     readonly name: string;
+    /**
+     * An explicit address change for this table.  The desired table remains
+     * identified by `name`; `from` and `to` make the otherwise ambiguous
+     * rename/schema move an authored transition rather than inferred drift.
+     */
+    readonly readdress?: TableReaddressDeclaration;
+    /**
+     * Declare that this named, pre-existing table is to enter managed state.
+     * Existing objects are otherwise drift; adoption is never inferred.
+     */
+    readonly adopt?: true;
+    /** Request a reviewed retire-and-create replacement of this unchanged table. */
+    readonly replace?: true;
     /** Stable logical identity, when attached by an engine-neutral carrier. */
     readonly logicalIdentity?: LogicalIdentity;
     /** Column definitions */
     readonly columns: readonly ColumnIR[];
     /** Primary key (single column or composite); omitted for junction tables without explicit PK */
     readonly primaryKey?: string | readonly string[];
+    /** Physical PostgreSQL primary-key constraint name when known. */
+    readonly primaryKeyName?: string;
     /** Foreign key constraints */
     readonly foreignKeys: readonly ForeignKeyIR[];
     /** Index definitions */
@@ -371,6 +404,20 @@ interface TableIR {
     /** Row-Level Security policies */
     readonly policies?: readonly PolicyIR[];
 }
+/** One endpoint of an authored table re-addressing declaration. */
+interface TableReaddressAddress {
+    readonly name: string;
+    readonly schema?: string;
+    /** Deliberately carried through so the command can refuse the named kind. */
+    readonly kind?: string;
+    /** Deliberately carried through so the command can refuse cross-database moves. */
+    readonly database?: string;
+}
+/** A declared rename or schema move; execution currently supports tables only. */
+interface TableReaddressDeclaration {
+    readonly from: TableReaddressAddress;
+    readonly to: TableReaddressAddress;
+}
 /**
  * Relation definition with planning metadata
  */
@@ -449,7 +496,10 @@ interface ModelIR {
     readonly externalTables?: ReadonlySet<string>;
     /** Relation definitions indexed by "source.name" */
     readonly relations: ReadonlyMap<string, RelationIR>;
-    /** ENUM type definitions indexed by name */
+    /**
+     * ENUM type definitions keyed by `EnumIR.name`, the physical type name. A key
+     * that differs from its value's `name` is refused wherever enums are handled.
+     */
     readonly enums?: ReadonlyMap<string, EnumIR>;
     /** Extension names to ensure (CREATE EXTENSION IF NOT EXISTS) */
     readonly extensions?: readonly string[];
@@ -1077,13 +1127,19 @@ interface WhereJsonExistsIntent {
     readonly field: string;
     readonly key: string | ParamIntent;
 }
-/** WHERE clause using a custom expression with comparison */
-interface WhereExpressionIntent {
+/** WHERE clause using a custom expression, optionally compared to a value. */
+type WhereExpressionIntent = {
     readonly kind: 'expression';
     readonly expr: ExpressionIntent;
     readonly operator: ComparisonOperator;
     readonly value: unknown;
-}
+} | {
+    readonly kind: 'expression';
+    readonly expr: StandaloneWhereExpressionIntent;
+    /** A standalone expression that is already a SQL predicate. */
+    readonly operator?: never;
+    readonly value?: never;
+};
 /**
  * Where intent - filter conditions union type
  * Discriminated union using 'kind' field
@@ -1233,11 +1289,20 @@ interface ColumnAliasIntent {
 }
 /**
  * Relation column expression: select a column from a related table
- * Auto-creates JOIN via include mechanism and selects with custom alias
- * @example { kind: 'relationColumn', relation: 'category', column: 'name', as: 'categoryName' }
- *          → SELECT t1."name" AS "categoryName" (where t1 is the joined category table)
- * @example { kind: 'relationColumn', relation: 'category.parent', column: 'name', as: 'parentCategoryName' }
- *          → Multi-level join: products → category → parent, select parent.name
+ * The query must already emit the named relation's JOIN, through `.join()` or
+ * an include with an explicit outer join. Without one, compilation reports
+ * `relation column "<relation>"."<column>" has no emitted alias in this query`.
+ * A bare include aggregates the relation instead, and the column lands inside
+ * `<relation>_json` rather than under its own alias (#793).
+ * @example orm.select('products').join('category').columns([
+ *            relationColumn('category', 'name', 'categoryName'),
+ *          ])
+ * @example orm.select('products').include('category', { join: 'left' }).columns([
+ *            relationColumn('category', 'name', 'categoryName'),
+ *          ])
+ *
+ * Deriving a join would choose join type, null behavior, and row multiplication
+ * on the caller's behalf; that is a separate feature.
  */
 interface RelationColumnIntent {
     readonly kind: 'relationColumn';
@@ -1427,6 +1492,14 @@ interface JsonPathExtractIntent {
     readonly mode: 'json' | 'text';
     readonly as?: string | undefined;
 }
+/**
+ * Operators whose result is a SQL predicate.
+ *
+ * This is deliberately closed: `op()` only brands these literal operators as
+ * predicates. Arbitrary operator strings remain ordinary expressions unless a
+ * caller explicitly opts into `unsafeAsPredicate()`.
+ */
+type PredicateOperator = '=' | '!=' | '<>' | '<' | '<=' | '>' | '>=' | 'AND' | 'OR' | 'NOT' | '@@' | '@@@' | '&&' | '<@' | '@>';
 /** Custom binary operator expression (e.g., <=> for pgvector) */
 interface CustomOpExpressionIntent {
     readonly kind: 'customOp';
@@ -1514,6 +1587,14 @@ interface UnaryExpressionIntent {
  * Extensible for future expression types
  */
 type ExpressionIntent = ColumnExpressionIntent | CoalesceExpressionIntent | RawExpressionIntent | ColumnAliasIntent | RelationColumnIntent | WindowIntent | AggregateExpressionIntent | PseudoColumnExpressionIntent | FunctionExpressionIntent | SubqueryExpressionIntent | ArithmeticExpressionIntent | LiteralExpressionIntent | ComparisonExpressionIntent | CaseExpressionIntent | JsonExtractIntent | JsonContainsIntent | JsonExistsIntent | JsonPathExtractIntent | CustomOpExpressionIntent | CustomFnExpressionIntent | RefExpressionIntent | ParamExpressionIntent | CastExpressionIntent | UnaryExpressionIntent | NamedArgExpressionIntent | StarExpressionIntent | ArrayExpressionIntent;
+/**
+ * Expression intents that the standalone `WHERE` expression compiler accepts.
+ *
+ * This deliberately excludes SELECT-only and planner-only expression kinds.
+ * A standalone expression is used only when a local predicate wrapper derives
+ * `{ kind: 'expression', expr }` for `WHERE`.
+ */
+type StandaloneWhereExpressionIntent = CustomOpExpressionIntent | CustomFnExpressionIntent | RefExpressionIntent | ParamExpressionIntent | CastExpressionIntent | LiteralExpressionIntent | UnaryExpressionIntent | NamedArgExpressionIntent | StarExpressionIntent | ArrayExpressionIntent | SubqueryExpressionIntent | RelationColumnIntent | CaseExpressionIntent;
 /**
  * Window function types for OVER clause analytics.
  * - Ranking: row_number, rank, dense_rank (no field required)
@@ -2550,6 +2631,8 @@ type OutputReadHandling = {
     readonly table: string;
     readonly column: string;
     readonly js: ColumnJsReadType;
+    /** Emitted nested JSON key; absent metadata keeps legacy column lookup. */
+    readonly outputKey?: string;
 } | {
     readonly kind: 'none';
 };
@@ -3124,6 +3207,12 @@ interface BaseAdapter {
      * their actionable refusal before any capability preflight.
      */
     readonly connectionAvailability?: ConnectionAvailability;
+    /**
+     * Optional side-effect-free execution availability check.
+     *
+     * When present, core uses this instead of probing a raw connection handle.
+     */
+    executionAvailable?(): boolean;
     /**
      * Whether this adapter instance is scoped inside a transaction.
      * Compile-only adapters and adapters without an active transaction report false.
@@ -3183,8 +3272,8 @@ interface ExecutingAdapter extends BaseAdapter {
     /** Execute a query and return all results. */
     execute<T>(query: CompiledQuery<T>): Promise<T[]>;
     /** Execute a compiled query and return the rows plus result metadata, when the adapter supports it. */
-    executeWithMeta?<T = unknown>(query: CompiledQuery<T>): Promise<{
-        readonly rows: T[];
+    executeWithMeta?(query: CompiledQuery): Promise<{
+        readonly rows: readonly unknown[];
         readonly rowCount: number;
         readonly command?: string;
     }>;
@@ -3308,7 +3397,7 @@ interface RawSqlAdapter extends BaseAdapter {
 /**
  * PostgreSQL index access method.
  */
-type IndexMethod = 'btree' | 'hash' | 'gist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat' | 'bm25';
+type IndexMethod = 'btree' | 'hash' | 'gist' | 'gin' | 'brin' | 'spgist' | 'bloom' | 'hnsw' | 'ivfflat' | 'bm25';
 /** A column reference in an index: either a column name or an expression. */
 type IndexColumnDef = string | {
     expression: string;
@@ -3402,25 +3491,12 @@ interface TableDDLGeneratorAdapter {
      */
     storageSize?(table: string, schema?: string): Promise<number>;
 }
-/**
- * DDL-generating adapter - can generate DDL (CREATE TABLE statements) from a schema.
- */
-interface DDLGeneratingAdapter extends BaseAdapter {
-    /**
-     * Generate DDL statements from a schema.
-     *
-     * @param schema - The ModelIR schema to generate DDL from
-     * @param options - Optional adapter-specific options (e.g., includeDropStatements)
-     * @returns Array of DDL statements (CREATE TABLE, CREATE INDEX, etc.)
-     */
-    generateDDL(schema: ModelIR, options?: Record<string, unknown>): string[];
-}
 /**
  * Database adapter interface - full adapter with all capabilities.
  *
  * @typeParam DB - Database schema type for type inference
  */
-interface Adapter<DB = unknown> extends CompilingAdapter, ExecutingAdapter, StreamingAdapter, IntrospectingAdapter, TransactionalAdapter<DB>, RawSqlAdapter, DDLGeneratingAdapter, TableDDLGeneratorAdapter {
+interface Adapter<DB = unknown> extends CompilingAdapter, ExecutingAdapter, StreamingAdapter, IntrospectingAdapter, TransactionalAdapter<DB>, RawSqlAdapter, TableDDLGeneratorAdapter {
     /**
      * Naming convention used by this adapter.
      *
@@ -3439,7 +3515,7 @@ interface Adapter<DB = unknown> extends CompilingAdapter, ExecutingAdapter, Stre
  * @deprecated Existing `CompileOnlyAdapter` annotations remain valid. Use
  * `Adapter` when direct execution calls are needed.
  */
-type CompileOnlyAdapter<DB = unknown> = CompilingAdapter & DDLGeneratingAdapter & TableDDLGeneratorAdapter & {
+type CompileOnlyAdapter<DB = unknown> = CompilingAdapter & TableDDLGeneratorAdapter & {
     /** Naming convention used by this adapter. */
     readonly dbCasing: DbCasing;
     /** Create a schema-scoped compile-only adapter. */
@@ -3521,4 +3597,4 @@ interface TranslationContext {
     readonly dialectCapabilities: DialectCapabilities;
 }
 
-export { type CustomOpExpressionIntent as $, type Adapter as A, type BaseAdapter as B, type CompiledQuery as C, type CastExpressionIntent as D, type CheckConstraintIR as E, type CoalesceExpressionIntent as F, type ColumnAliasIntent as G, type ColumnExpressionIntent as H, type ColumnIR as I, type ColumnJsReadType as J, type ColumnListInput as K, type ColumnType as L, type CommonColumnType as M, type NqlBindingRelationType as N, type ComparisonExpressionIntent as O, type PlanReport as P, type ComparisonOperator as Q, type CompileOnlyAdapter as R, type CompileOptions as S, type CompileOptionsBase as T, type CompileResultWithIncludes as U, type CompiledNqlQuery as V, type CompilingAdapter as W, type ConnectionAvailability as X, type CreateIndexOptions as Y, type CteQueryIntent as Z, type CustomFnExpressionIntent as _, type CompiledColumnMetadata as a, type NqlBindingColumnLineage as a$, type CustomTraversal as a0, type DDLFeature as a1, type DDLFeatureElementMap as a2, type DDLFeatureVersionRange as a3, type DDLGeneratingAdapter as a4, type DbCasing as a5, type DecisionType as a6, type DeleteIntent as a7, type DialectCapabilities as a8, type DialectName as a9, type InsertFromIntent as aA, type InsertIntent as aB, type IntrospectingAdapter as aC, type IntrospectionOptions as aD, type IntrospectionResult as aE, type IsTypeSupported as aF, type JoinDefault as aG, type JoinIntent as aH, type JsonAggOrderByEntry as aI, type JsonContainsIntent as aJ, type JsonExistsIntent as aK, type JsonExtractIntent as aL, type JsonPathExtractIntent as aM, type LiteralExpressionIntent as aN, type LockIntent as aO, type LockStrength as aP, type LockWaitPolicy as aQ, type LogicalIdentity as aR, type LogicalIdentityCarrier as aS, type LogicalOperator as aT, type MSSQLColumnType as aU, type ModelIR as aV, type MutationIntent as aW, type MutationReturningItem as aX, type MySQLColumnType as aY, type NamedArgExpressionIntent as aZ, type NestedOutputReadHandling as a_, type DiffSummary as aa, type DropIndexOptions as ab, type DuckDBColumnType as ac, type Dump as ad, type DumpMeta as ae, type DumpSequenceStep as af, type EdgeTableTraversal as ag, type EmitJoinClause as ah, type EnumIR as ai, type ExecutingAdapter as aj, type ExpressionIntent as ak, type FeatureBehaviorConfig as al, type FeatureTranslator as am, type FeatureWarning as an, type FieldRef as ao, type FilterStrategy as ap, type ForeignKeyIR as aq, type FunctionExpressionIntent as ar, type HierarchyIR as as, type IncludeIntent as at, type IncludeRecursiveOptions as au, type IncludeStrategy as av, type IndexColumnDef as aw, type IndexIR as ax, type IndexInfo as ay, type IndexMethod as az, type AdapterCapabilities as b, type RelationType as b$, type NqlBindingColumnTypeInfo as b0, type NqlBindingColumnUntypeableReason as b1, type NqlBindingOutputSchema as b2, type NqlBindingRelationFilterMetadata as b3, type NqlBindingVirtualRelation as b4, type NqlBindingVirtualRelationHop as b5, type NqlBindingVirtualRelationRecursive as b6, type NqlProgramSequenceStep as b7, type NqlRuntimeBinding as b8, type NullOperator as b9, type PseudoColumnTraversal as bA, type QueryIntent as bB, type RangeOperand as bC, type RangeOperator as bD, type RangeValue as bE, type RankingWindowFunction as bF, type RankingWindowIntent as bG, type RawCteIntent as bH, type RawExpressionIntent as bI, type RawSqlAdapter as bJ, type RecursiveAdvancedOptions as bK, type RecursiveDedupe as bL, type RecursiveDirection as bM, type RecursiveEmitOptions as bN, type RecursiveExistsOptions as bO, type RecursiveIntent as bP, type RecursiveMetadata as bQ, type RecursiveNodeIdExpr as bR, type RecursivePlanOptions as bS, type RecursivePlanReport as bT, type RecursiveTrackOptions as bU, type RecursiveTraversal as bV, type RefExpressionIntent as bW, type RelationColumnIntent as bX, type RelationIR as bY, type RelationKind as bZ, type RelationOperator as b_, type NullsPosition as ba, type OffsetWindowFunction as bb, type OffsetWindowIntent as bc, type OnDeleteAction as bd, type OperationKindRef as be, type Optionality as bf, type OrderByExpressionIntent as bg, type OrderByFieldIntent as bh, type OrderByIntent as bi, type OutputDescriptor as bj, type OutputReadHandling as bk, type OutputSource as bl, type OutputValueShape as bm, type ParamExpressionIntent as bn, type ParamIntent as bo, type PartitionIR as bp, type PinnedConnectionOptions as bq, type PlanDecision as br, type PlanOptions as bs, type PlanWarning as bt, type PlanWarningCode as bu, type PolicyIR as bv, type PostgresColumnType as bw, type PostgresOnlyColumnType as bx, type PseudoColumnExpressionIntent as by, type PseudoColumnMetadata as bz, type AdapterLogger as c, type WindowIntent as c$, type RequiredEnumLabelIR as c0, type ResolvedIncludeStrategy as c1, type SQLiteColumnType as c2, type SchemaChange as c3, type SchemaDiff as c4, type SelectAggregateIntent as c5, type SelectAllIntent as c6, type SelectFieldsIntent as c7, type SelectIntent as c8, type SelectWithExpressionsIntent as c9, type UpsertConflictAction as cA, type UpsertConflictTarget as cB, type UpsertFromIntent as cC, type UpsertIntent as cD, type VacuumOptions as cE, type WhereAndIntent as cF, type WhereAnyIntent as cG, type WhereComparisonIntent as cH, type WhereExistsIntent as cI, type WhereExpressionIntent as cJ, type WhereInIntent as cK, type WhereInSubqueryIntent as cL, type WhereInValueIntent as cM, type WhereIntent as cN, type WhereJsonContainsIntent as cO, type WhereJsonExistsIntent as cP, type WhereLikeIntent as cQ, type WhereNotExistsIntent as cR, type WhereNotIntent as cS, type WhereNullIntent as cT, type WhereOrIntent as cU, type WhereRangeIntent as cV, type WhereRawExistsIntent as cW, type WhereRawNotExistsIntent as cX, type WhereRelationFilterIntent as cY, type WhereSubqueryIntent as cZ, type WindowFunction as c_, type SemanticArtifactId as ca, type SemanticArtifactRef as cb, type SequenceIR as cc, type SetOperationIntent as cd, type SetOperationType as ce, type SimpleCteIntent as cf, type SortDirection as cg, type StarExpressionIntent as ch, type StreamingAdapter as ci, type StringOperator as cj, type SubqueryExpressionIntent as ck, type SubqueryIncludeInfo as cl, type SubqueryRefIntent as cm, type SupportedColumnTypes as cn, type TableDDLGeneratorAdapter as co, type TableIR as cp, type TransactionBeginOptions as cq, type TransactionOptions as cr, type TransactionalAdapter as cs, type TranslationContext as ct, type TruncateOptions as cu, type TrustRoot as cv, type UnaryExpressionIntent as cw, type UnnestCteIntent as cx, type UnsupportedFeatureBehavior as cy, type UpdateIntent as cz, type AdapterStreamOptions as d, type WindowOrderBy as d0, getNodeIdAlias as d1, isFieldRef as d2, isParamIntent as d3, resolveOutputReadHandling as d4, toColumnList as d5, type AdjacencyTraversal as e, type AggOrderByArg as f, type AggregateCountIntent as g, type AggregateExpressionIntent as h, type AggregateFieldIntent as i, type AggregateFunction as j, type AggregateIntent as k, type AggregateWindowFunction as l, type AggregateWindowIntent as m, type AliasIncludedColumnsMode as n, type AlterColumnOptions as o, type AmbiguityCheckResult as p, type ArithmeticExpressionIntent as q, type ArrayExpressionIntent as r, type ArrayOperator as s, type AuthorAttestedNativeDefault as t, type AuthorAttester as u, type BatchUpdateIntent as v, type BatchValuesJoinPayload as w, type CTEDefinition as x, type Cardinality as y, type CaseExpressionIntent as z };
+export { type CustomOpExpressionIntent as $, type Adapter as A, type BaseAdapter as B, type CompiledQuery as C, type CastExpressionIntent as D, type CheckConstraintIR as E, type CoalesceExpressionIntent as F, type ColumnAliasIntent as G, type ColumnExpressionIntent as H, type ColumnIR as I, type ColumnJsReadType as J, type ColumnListInput as K, type ColumnType as L, type CommonColumnType as M, type NqlBindingRelationType as N, type ComparisonExpressionIntent as O, type PlanReport as P, type ComparisonOperator as Q, type CompileOnlyAdapter as R, type CompileOptions as S, type CompileOptionsBase as T, type CompileResultWithIncludes as U, type CompiledNqlQuery as V, type CompilingAdapter as W, type ConnectionAvailability as X, type CreateIndexOptions as Y, type CteQueryIntent as Z, type CustomFnExpressionIntent as _, type CompiledColumnMetadata as a, type NqlBindingColumnTypeInfo as a$, type CustomTraversal as a0, type DDLFeature as a1, type DDLFeatureElementMap as a2, type DDLFeatureVersionRange as a3, type DbCasing as a4, type DecisionType as a5, type DeleteIntent as a6, type DialectCapabilities as a7, type DialectName as a8, type DiffSummary as a9, type InsertIntent as aA, type IntrospectingAdapter as aB, type IntrospectionOptions as aC, type IntrospectionResult as aD, type IsTypeSupported as aE, type JoinDefault as aF, type JoinIntent as aG, type JsonAggOrderByEntry as aH, type JsonContainsIntent as aI, type JsonExistsIntent as aJ, type JsonExtractIntent as aK, type JsonPathExtractIntent as aL, type LiteralExpressionIntent as aM, type LockIntent as aN, type LockStrength as aO, type LockWaitPolicy as aP, type LogicalIdentity as aQ, type LogicalIdentityCarrier as aR, type LogicalOperator as aS, type MSSQLColumnType as aT, type ModelIR as aU, type MutationIntent as aV, type MutationReturningItem as aW, type MySQLColumnType as aX, type NamedArgExpressionIntent as aY, type NestedOutputReadHandling as aZ, type NqlBindingColumnLineage as a_, type DropIndexOptions as aa, type DuckDBColumnType as ab, type Dump as ac, type DumpMeta as ad, type DumpSequenceStep as ae, type EdgeTableTraversal as af, type EmitJoinClause as ag, type EnumIR as ah, type ExecutingAdapter as ai, type ExpressionIntent as aj, type FeatureBehaviorConfig as ak, type FeatureTranslator as al, type FeatureWarning as am, type FieldRef as an, type FilterStrategy as ao, type ForeignKeyIR as ap, type FunctionExpressionIntent as aq, type HierarchyIR as ar, type IncludeIntent as as, type IncludeRecursiveOptions as at, type IncludeStrategy as au, type IndexColumnDef as av, type IndexIR as aw, type IndexInfo as ax, type IndexMethod as ay, type InsertFromIntent as az, type AdapterCapabilities as b, type RelationType as b$, type NqlBindingColumnUntypeableReason as b0, type NqlBindingOutputSchema as b1, type NqlBindingRelationFilterMetadata as b2, type NqlBindingVirtualRelation as b3, type NqlBindingVirtualRelationHop as b4, type NqlBindingVirtualRelationRecursive as b5, type NqlProgramSequenceStep as b6, type NqlRuntimeBinding as b7, type NullOperator as b8, type NullsPosition as b9, type PseudoColumnTraversal as bA, type QueryIntent as bB, type RangeOperand as bC, type RangeOperator as bD, type RangeValue as bE, type RankingWindowFunction as bF, type RankingWindowIntent as bG, type RawCteIntent as bH, type RawExpressionIntent as bI, type RawSqlAdapter as bJ, type RecursiveAdvancedOptions as bK, type RecursiveDedupe as bL, type RecursiveDirection as bM, type RecursiveEmitOptions as bN, type RecursiveExistsOptions as bO, type RecursiveIntent as bP, type RecursiveMetadata as bQ, type RecursiveNodeIdExpr as bR, type RecursivePlanOptions as bS, type RecursivePlanReport as bT, type RecursiveTrackOptions as bU, type RecursiveTraversal as bV, type RefExpressionIntent as bW, type RelationColumnIntent as bX, type RelationIR as bY, type RelationKind as bZ, type RelationOperator as b_, type OffsetWindowFunction as ba, type OffsetWindowIntent as bb, type OnDeleteAction as bc, type OperationKindRef as bd, type Optionality as be, type OrderByExpressionIntent as bf, type OrderByFieldIntent as bg, type OrderByIntent as bh, type OutputDescriptor as bi, type OutputReadHandling as bj, type OutputSource as bk, type OutputValueShape as bl, type ParamExpressionIntent as bm, type ParamIntent as bn, type PartitionIR as bo, type PinnedConnectionOptions as bp, type PlanDecision as bq, type PlanOptions as br, type PlanWarning as bs, type PlanWarningCode as bt, type PolicyIR as bu, type PostgresColumnType as bv, type PostgresOnlyColumnType as bw, type PredicateOperator as bx, type PseudoColumnExpressionIntent as by, type PseudoColumnMetadata as bz, type AdapterLogger as c, type WhereRelationFilterIntent as c$, type RequiredEnumLabelIR as c0, type ResolvedIncludeStrategy as c1, type SQLiteColumnType as c2, type SchemaChange as c3, type SchemaDiff as c4, type SelectAggregateIntent as c5, type SelectAllIntent as c6, type SelectFieldsIntent as c7, type SelectIntent as c8, type SelectWithExpressionsIntent as c9, type UnnestCteIntent as cA, type UnsupportedFeatureBehavior as cB, type UpdateIntent as cC, type UpsertConflictAction as cD, type UpsertConflictTarget as cE, type UpsertFromIntent as cF, type UpsertIntent as cG, type VacuumOptions as cH, type WhereAndIntent as cI, type WhereAnyIntent as cJ, type WhereComparisonIntent as cK, type WhereExistsIntent as cL, type WhereExpressionIntent as cM, type WhereInIntent as cN, type WhereInSubqueryIntent as cO, type WhereInValueIntent as cP, type WhereIntent as cQ, type WhereJsonContainsIntent as cR, type WhereJsonExistsIntent as cS, type WhereLikeIntent as cT, type WhereNotExistsIntent as cU, type WhereNotIntent as cV, type WhereNullIntent as cW, type WhereOrIntent as cX, type WhereRangeIntent as cY, type WhereRawExistsIntent as cZ, type WhereRawNotExistsIntent as c_, type SemanticArtifactId as ca, type SemanticArtifactRef as cb, type SequenceIR as cc, type SetOperationIntent as cd, type SetOperationType as ce, type SimpleCteIntent as cf, type SortDirection as cg, type StandaloneWhereExpressionIntent as ch, type StarExpressionIntent as ci, type StreamingAdapter as cj, type StringOperator as ck, type SubqueryExpressionIntent as cl, type SubqueryIncludeInfo as cm, type SubqueryRefIntent as cn, type SupportedColumnTypes as co, type TableDDLGeneratorAdapter as cp, type TableIR as cq, type TableReaddressAddress as cr, type TableReaddressDeclaration as cs, type TransactionBeginOptions as ct, type TransactionOptions as cu, type TransactionalAdapter as cv, type TranslationContext as cw, type TruncateOptions as cx, type TrustRoot as cy, type UnaryExpressionIntent as cz, type AdapterStreamOptions as d, type WhereSubqueryIntent as d0, type WindowFunction as d1, type WindowIntent as d2, type WindowOrderBy as d3, getNodeIdAlias as d4, isFieldRef as d5, isParamIntent as d6, resolveOutputReadHandling as d7, toColumnList as d8, type AdjacencyTraversal as e, type AggOrderByArg as f, type AggregateCountIntent as g, type AggregateExpressionIntent as h, type AggregateFieldIntent as i, type AggregateFunction as j, type AggregateIntent as k, type AggregateWindowFunction as l, type AggregateWindowIntent as m, type AliasIncludedColumnsMode as n, type AlterColumnOptions as o, type AmbiguityCheckResult as p, type ArithmeticExpressionIntent as q, type ArrayExpressionIntent as r, type ArrayOperator as s, type AuthorAttestedNativeDefault as t, type AuthorAttester as u, type BatchUpdateIntent as v, type BatchValuesJoinPayload as w, type CTEDefinition as x, type Cardinality as y, type CaseExpressionIntent as z };

package/dist/adapter-sdk.d.ts

@@ -1,4 +1,4 @@
-import { C as CompiledQuery, a as CompiledColumnMetadata, P as PlanReport } from './adapter-CjwnHeg4.js';
+import { C as CompiledQuery, a as CompiledColumnMetadata, P as PlanReport } from './adapter-DXjfHEAf.js';
 
 /**
  * Stable SPI for implementing the `Adapter` port. Only stable helpers required to construct/validate a

package/dist/{chunk-SEWKTHUK.js → chunk-X5OQYLAK.js}

@@ -334,6 +334,108 @@ function resolveOutputReadHandling(descriptor) {
   }
 }
 
+// src/physical-name-inventory.ts
+var PhysicalNameInventoryDuplicateError = class extends Error {
+  constructor(scope, first, second) {
+    super(
+      `Duplicate physical-name inventory ${scope}: "${first.physical}" is claimed by ${addressText(first.logical)} and ${addressText(second.logical)}.`
+    );
+    this.scope = scope;
+    this.first = first;
+    this.second = second;
+    this.name = "PhysicalNameInventoryDuplicateError";
+  }
+  scope;
+  first;
+  second;
+};
+function createPhysicalNameInventory(entries) {
+  const byAddress = /* @__PURE__ */ new Map();
+  const tables = /* @__PURE__ */ new Map();
+  const columns = /* @__PURE__ */ new Map();
+  const copied = entries.map(
+    (entry) => Object.freeze({
+      logical: Object.freeze({ ...entry.logical }),
+      physical: entry.physical,
+      ...entry.sequenceProvenance === void 0 ? {} : { sequenceProvenance: entry.sequenceProvenance }
+    })
+  );
+  const physicalTables = /* @__PURE__ */ new Map();
+  for (const entry of copied) {
+    if (entry.logical.kind === "table")
+      physicalTables.set(
+        `${entry.logical.schema}\0${entry.logical.name}`,
+        entry.physical
+      );
+  }
+  for (const entry of copied) {
+    const key = addressKey(entry.logical);
+    const firstAddress = byAddress.get(key);
+    if (firstAddress)
+      throw new PhysicalNameInventoryDuplicateError(
+        "logical-address",
+        firstAddress,
+        entry
+      );
+    byAddress.set(key, entry);
+    if (entry.logical.kind === "table") {
+      const tableKey = `${entry.logical.schema}\0${entry.physical}`;
+      const firstTable = tables.get(tableKey);
+      if (firstTable)
+        throw new PhysicalNameInventoryDuplicateError(
+          "table",
+          firstTable,
+          entry
+        );
+      tables.set(tableKey, entry);
+    }
+    if (entry.logical.kind === "column") {
+      const physicalTable = physicalTables.get(
+        `${entry.logical.schema}\0${entry.logical.table}`
+      ) ?? entry.logical.table;
+      const columnKey = `${entry.logical.schema}\0${physicalTable}\0${entry.physical}`;
+      const firstColumn = columns.get(columnKey);
+      if (firstColumn)
+        throw new PhysicalNameInventoryDuplicateError(
+          "column",
+          firstColumn,
+          entry
+        );
+      columns.set(columnKey, entry);
+    }
+  }
+  const sorted = Object.freeze(
+    [...copied].sort(
+      (left, right) => addressKey(left.logical) < addressKey(right.logical) ? -1 : addressKey(left.logical) > addressKey(right.logical) ? 1 : 0
+    )
+  );
+  return Object.freeze({
+    entries: sorted,
+    has(address) {
+      return byAddress.has(addressKey(address));
+    },
+    get(address) {
+      const entry = byAddress.get(addressKey(address));
+      if (!entry) throw new PhysicalNameInventoryMissingError(address);
+      return entry.physical;
+    }
+  });
+}
+var PhysicalNameInventoryMissingError = class extends Error {
+  constructor(address) {
+    super(`Physical name inventory has no entry for ${addressText(address)}.`);
+    this.address = address;
+    this.name = "PhysicalNameInventoryMissingError";
+  }
+  address;
+};
+function addressKey(address) {
+  return "table" in address ? `${address.kind}\0${address.schema}\0${address.table}\0${address.name}` : `${address.kind}\0${address.schema}\0${address.name}`;
+}
+function addressText(address) {
+  return "table" in address ? `${address.kind} ${address.schema}.${address.table}.${address.name}` : `${address.kind} ${address.schema}.${address.name}`;
+}
+
 // src/relation-key-fields.ts
 var DEFAULT_REFERENCED_COLUMN = "id";
 function columnListValue(columns, shape) {
@@ -370,6 +472,151 @@ function buildRelationKeyFields(fk, direction, options = {}) {
 // src/transition/execution-contract.ts
 var EXECUTION_CONTRACT_VERSION = 1;
 
+// src/transition/ledger.ts
+var LEDGER_EVENT_KINDS = [
+  "adopt-intent",
+  "adopt",
+  "intent",
+  "retire-intent",
+  "readdress-intent",
+  "refused",
+  "executing",
+  "observed",
+  "absent",
+  "indeterminate",
+  "resolved",
+  "readdressed-to",
+  "readdressed-from",
+  "released"
+];
+function canonicalResourceParent(address) {
+  return {
+    engine: address.engine,
+    database: address.database,
+    ...address.schema === void 0 ? {} : { schema: address.schema },
+    ...address.parent === void 0 || address.parent === null ? {} : { parent: canonicalResourceParent(address.parent) },
+    kind: address.kind,
+    name: address.name
+  };
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  if (Array.isArray(value)) {
+    const entries = [];
+    for (let index = 0; index < value.length; index += 1)
+      entries.push(
+        Object.hasOwn(value, index) ? canonicalJson(value[index]) : "null"
+      );
+    return `[${entries.join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function normalizedParent(parent) {
+  if (parent === null || parent === void 0) return null;
+  const canonical = canonicalResourceParent(parent);
+  return {
+    engine: canonical.engine,
+    database: canonical.database,
+    ...canonical.schema === void 0 ? {} : { schema: canonical.schema },
+    parent: normalizedParent(canonical.parent),
+    kind: canonical.kind,
+    name: canonical.name
+  };
+}
+function canonicalLedgerAddress(address) {
+  return {
+    scope: address.scope,
+    engine: address.engine,
+    database: address.database,
+    ...address.schema === void 0 ? {} : { schema: address.schema },
+    parent: normalizedParent(address.parent),
+    kind: address.kind,
+    name: address.name
+  };
+}
+function sameLedgerAddress(left, right) {
+  return ledgerAddressKey(left) === ledgerAddressKey(right);
+}
+function ledgerAddressKey(address) {
+  return canonicalJson(canonicalLedgerAddress(address));
+}
+function ledgerAddressParentJson(address) {
+  return canonicalJson(normalizedParent(address.parent));
+}
+
+// src/transition/refusal.ts
+var REFUSAL_VOCABULARY = {
+  "ERR-01": {
+    cause: "unaccepted non-transactional segment",
+    withheldAuthority: "non-transactional execution authority",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-02": {
+    cause: "pre-existing object has no admitted adoption",
+    withheldAuthority: "creation authority over an occupied address",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-03": {
+    cause: "managed-ledger preflight is not current",
+    withheldAuthority: "managed-ledger mutation authority",
+    resolvingCommand: "dbsp preflight --reinitialize"
+  },
+  "ERR-04": {
+    cause: "removal containment cannot be proven",
+    withheldAuthority: "destructive removal authority",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-05": {
+    cause: "recorded identity differs from the live object",
+    withheldAuthority: "managed mutation authority",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-06": {
+    cause: "managed-ledger lineage does not match this target",
+    withheldAuthority: "managed-ledger mutation authority",
+    resolvingCommand: "dbsp preflight --reinitialize"
+  },
+  "ERR-07": {
+    cause: "target database is read-only",
+    withheldAuthority: "database write authority",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-08": {
+    cause: "ledger chain is malformed",
+    withheldAuthority: "managed mutation authority",
+    resolvingCommand: "dbsp inspect"
+  },
+  "ERR-09": {
+    cause: "catalogue read is unavailable",
+    withheldAuthority: "outcome classification authority",
+    resolvingCommand: "dbsp reconcile"
+  },
+  "ERR-10": {
+    cause: "recorded-plan path cannot execute a removal",
+    withheldAuthority: "recorded-plan removal execution",
+    resolvingCommand: "dbsp apply"
+  },
+  "ERR-11": {
+    cause: "recovery proved the interrupted operation had no effect",
+    withheldAuthority: "recovery execution authority",
+    resolvingCommand: "dbsp reconcile"
+  }
+};
+function refusalFor(code, input) {
+  void input.address;
+  return { code, ...REFUSAL_VOCABULARY[code], state: input.state };
+}
+
+// src/transition/resource.ts
+function sameControllerIdentity(recorded, current) {
+  return recorded.name === current.name && recorded.oid === current.oid;
+}
+
 export {
   convertBigintJsReadValue,
   toColumnList,
@@ -427,7 +674,18 @@ export {
   resolveJsonAggOrderKey,
   isValidSchema,
   resolveOutputReadHandling,
+  PhysicalNameInventoryDuplicateError,
+  createPhysicalNameInventory,
+  PhysicalNameInventoryMissingError,
   buildRelationKeyFields,
-  EXECUTION_CONTRACT_VERSION
+  EXECUTION_CONTRACT_VERSION,
+  LEDGER_EVENT_KINDS,
+  canonicalResourceParent,
+  sameLedgerAddress,
+  ledgerAddressKey,
+  ledgerAddressParentJson,
+  REFUSAL_VOCABULARY,
+  refusalFor,
+  sameControllerIdentity
 };
-//# sourceMappingURL=chunk-SEWKTHUK.js.map
+//# sourceMappingURL=chunk-X5OQYLAK.js.map