@dbsp/core 3.0.0 → 3.2.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _dbsp_types from '@dbsp/types';
-import { PseudoColumnMetadata, RecursiveMetadata, RelationIR, RelationKind, AdapterCapabilities, Adapter, BaseAdapter, DDLGeneratingAdapter, ExecutingAdapter, IntrospectingAdapter, RawSqlAdapter, StreamingAdapter, TransactionalAdapter, ColumnType, WhereIntent, OnDeleteAction, ModelIR, DbCasing, QueryIntent, PlanOptions, PlanReport, RecursiveIntent, RecursivePlanOptions, RecursivePlanReport, TableIR, EnumIR, SequenceIR, AmbiguityCheckResult, DialectCapabilities, DDLFeature, DDLFeatureVersionRange, SelectIntent, IncludeIntent, AggregateIntent, OrderByIntent, SortDirection, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, Dump, SetOperationIntent, LockStrength, LockWaitPolicy, DumpMeta, JoinIntent, UnnestCteIntent, CteQueryIntent, CompileOptions, CompiledQuery, MutationIntent as MutationIntent$1, DumpSequenceStep, UpsertConflictTarget, UpsertConflictAction, RawCteIntent, TruncateOptions, VacuumOptions, AlterColumnOptions, CreateIndexOptions, DropIndexOptions, IndexInfo, ExpressionIntent, ComparisonOperator, WhereSubqueryIntent, SubqueryRefIntent, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereRelationFilterIntent, RecursiveExistsOptions, WhereExistsIntent, WhereInIntent, WhereNullIntent, WhereLikeIntent, WhereNotIntent, WhereNotExistsIntent, WhereOrIntent, WhereRawExistsIntent, WhereRawNotExistsIntent, WhereExpressionIntent, AggOrderByArg, RelationType as RelationType$1, Cardinality, FeatureWarning, UnsupportedFeatureBehavior, FeatureBehaviorConfig, RangeValue, WhereRangeIntent, SubqueryIncludeInfo } from '@dbsp/types';
-export { Adapter, AdapterCapabilities, AdapterLogger, AdapterStreamOptions, AdjacencyTraversal, AggregateExpressionIntent, AggregateFunction, AggregateIntent, AggregateWindowFunction, AliasIncludedColumnsMode, AlterColumnOptions, AmbiguityCheckResult, ArrayOperator, BaseAdapter, CTEDefinition, Cardinality, CaseExpressionIntent, CoalesceExpressionIntent, ColumnAliasIntent, ColumnExpressionIntent, ColumnIR, ColumnType, CommonColumnType, ComparisonExpressionIntent, ComparisonOperator, CompileOnlyAdapter, CompileOptions, CompileResultWithIncludes, CompiledQuery, CompilingAdapter, CreateIndexOptions, CustomTraversal, DDLGeneratingAdapter, DbCasing, DecisionType, DeleteIntent, DialectCapabilities, DialectName, DropIndexOptions, DuckDBColumnType, Dump, DumpMeta, EdgeTableTraversal, EmitJoinClause, ExecutingAdapter, ExpressionIntent, FilterStrategy, ForeignKeyIR, IncludeIntent, IncludeStrategy, IndexColumnDef, IndexIR, IndexInfo, IndexMethod, InsertFromIntent, InsertIntent, IntrospectingAdapter, IsTypeSupported, JoinDefault, JoinIntent, LiteralExpressionIntent, LogicalOperator, MSSQLColumnType, ModelIR, MutationIntent, MySQLColumnType, NullOperator, NullsPosition, OffsetWindowFunction, OnDeleteAction, Optionality, OrderByIntent, PartitionIR, PlanDecision, PlanOptions, PlanReport, PlanWarning, PlanWarningCode, PostgresColumnType, PostgresOnlyColumnType, PseudoColumnExpressionIntent, PseudoColumnMetadata, PseudoColumnTraversal, QueryIntent, RangeOperator, RangeValue, RankingWindowFunction, RawExpressionIntent, RawSqlAdapter, RecursiveAdvancedOptions, RecursiveDedupe, RecursiveDirection, RecursiveEmitOptions, RecursiveExistsOptions, RecursiveIntent, RecursiveMetadata, RecursiveNodeIdExpr, RecursivePlanOptions, RecursivePlanReport, RecursiveTrackOptions, RecursiveTraversal, RelationColumnIntent, RelationIR, RelationKind, RelationOperator, RelationType, ResolvedIncludeStrategy, SQLiteColumnType, SelectAggregateIntent, SelectAllIntent, SelectFieldsIntent, SelectIntent, SelectWithExpressionsIntent, SortDirection, StreamingAdapter, StringOperator, SubqueryIncludeInfo, SubqueryRefIntent, SupportedColumnTypes, TableIR, TransactionalAdapter, TruncateOptions, UpdateIntent, UpsertConflictAction, UpsertConflictTarget, UpsertFromIntent, UpsertIntent, VacuumOptions, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereExistsIntent, WhereInIntent, WhereIntent, WhereLikeIntent, WhereNotExistsIntent, WhereNotIntent, WhereNullIntent, WhereOrIntent, WhereRangeIntent, WhereRelationFilterIntent, WhereSubqueryIntent, WindowFunction, WindowIntent, WindowOrderBy, getNodeIdAlias, isAdjacencyTraversal, isAggregateWindowFunction, isCoalesceExpression, isColumnAliasExpression, isCustomTraversal, isDeleteIntent, isEdgeTableTraversal, isInsertIntent, isMutationIntent, isRankingWindowFunction, isRawExpression, isRecursiveIntent, isRelationColumnExpression, isSelectAggregate, isSelectAll, isSelectFields, isSelectWithExpressions, isSubqueryRef, isUpdateIntent, isUpsertIntent, isWhereAnd, isWhereAny, isWhereComparison, isWhereExists, isWhereIn, isWhereLike, isWhereLogical, isWhereNot, isWhereNotExists, isWhereNull, isWhereOr, isWhereRange, isWhereRelationBased, isWhereRelationFilter, isWhereSubquery, isWindowIntent } from '@dbsp/types';
+import { PseudoColumnMetadata, RecursiveMetadata, RelationIR, RelationKind, AdapterCapabilities, Adapter, BaseAdapter, DDLGeneratingAdapter, ExecutingAdapter, IntrospectingAdapter, RawSqlAdapter, StreamingAdapter, TransactionalAdapter, ColumnType, ColumnJsReadType as ColumnJsReadType$1, WhereIntent, OnDeleteAction, ModelIR, DbCasing, QueryIntent, PlanOptions, PlanReport, RecursiveIntent, RecursivePlanOptions, RecursivePlanReport, ObservationContext, TransitionConnectionPool, IssuedObservation, RecoveryArtefact, FingerprintManifest, OperationSemantics, OperationKindRef, PhysicalOperation, EvidenceObservation, DurableIntentRecord, OperationEffectAssessment, ObservationIssuer, ApplyGuard, OperationExecutionOutcome, TransactionalCompletionRecord, StepJournal, TransitionRule, EquivalenceCapability, CapabilityDescriptor, TransitionCompositionFact, RuleRef, SemanticArtifactRef, CheckConstraintIR, Comparator, EnumIR, ObservationRequest, EvidenceView, AdvisoryObservationId, AssumptionId, ClaimId, EvidenceId, SemanticArtifactId, IndexIR, ResourceAddress, ResourceSelector, ApplyPolicy, ApplyResult, TransitionCandidate, TransitionFragmentComposition, PlanAssessment, CompareOutcome, TransitionFragment, ProofClaim, Assumption, ProvenPlanShape, ApplicableAssessment, TransitionRunJournal, InapplicableAssessment, TableIR, SequenceIR, AmbiguityCheckResult, DialectCapabilities, DDLFeature, DDLFeatureVersionRange, SelectIntent, IncludeIntent, AggregateIntent, OrderByIntent, SortDirection, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, TransactionBeginOptions, Dump, SetOperationIntent, LockStrength, LockWaitPolicy, DumpMeta, JoinIntent, UnnestCteIntent, CteQueryIntent, CompileOptions, CompiledQuery, MutationIntent as MutationIntent$1, DumpSequenceStep, UpsertConflictTarget, UpsertConflictAction, RawCteIntent, TruncateOptions, VacuumOptions, AlterColumnOptions, CreateIndexOptions, DropIndexOptions, IndexInfo, TransactionOptions, PinnedConnectionOptions, ExpressionIntent, ComparisonOperator, WhereSubqueryIntent, SubqueryRefIntent, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereRelationFilterIntent, RecursiveExistsOptions, WhereExistsIntent, WhereInIntent, WhereNullIntent, WhereLikeIntent, WhereNotIntent, WhereNotExistsIntent, WhereOrIntent, WhereRawExistsIntent, WhereRawNotExistsIntent, WhereExpressionIntent, AggOrderByArg, RelationType as RelationType$1, Cardinality, FeatureWarning, UnsupportedFeatureBehavior, FeatureBehaviorConfig, RangeValue, WhereRangeIntent, SubqueryIncludeInfo } from '@dbsp/types';
+export { Adapter, AdapterCapabilities, AdapterLogger, AdapterStreamOptions, AdjacencyTraversal, AggregateExpressionIntent, AggregateFunction, AggregateIntent, AggregateWindowFunction, AliasIncludedColumnsMode, AlterColumnOptions, AmbiguityCheckResult, ApplicableAssessment, ApplicableEvaluation, ApplyPolicy, ArrayOperator, Assumption, BaseAdapter, CTEDefinition, CapabilityDescriptor, Cardinality, CaseExpressionIntent, CoalesceExpressionIntent, ColumnAliasIntent, ColumnExpressionIntent, ColumnIR, ColumnJsReadType, ColumnType, CommonColumnType, Comparator, CompareOutcome, ComparisonExpressionIntent, ComparisonOperator, CompileOnlyAdapter, CompileOptions, CompileResultWithIncludes, CompiledQuery, CompilingAdapter, CreateIndexOptions, CustomTraversal, DDLGeneratingAdapter, DbCasing, DecisionType, DeleteIntent, DialectCapabilities, DialectName, DropIndexOptions, DuckDBColumnType, Dump, DumpMeta, DurableIntentRecord, EdgeTableTraversal, EmitJoinClause, ExecutingAdapter, ExpressionIntent, FilterStrategy, FingerprintManifest, ForeignKeyIR, InapplicableAssessment, IncludeIntent, IncludeStrategy, IndexColumnDef, IndexIR, IndexInfo, IndexMethod, InsertFromIntent, InsertIntent, IntrospectingAdapter, IsTypeSupported, JoinDefault, JoinIntent, LiteralExpressionIntent, LogicalIdentity, LogicalIdentityCarrier, LogicalOperator, MSSQLColumnType, ModelIR, MutationIntent, MySQLColumnType, NullOperator, NullsPosition, ObservationContext, ObservationIssuer, ObservationRequest, OffsetWindowFunction, OnDeleteAction, OperationEffectAssessment, OperationSemantics, Optionality, OrderByIntent, PartitionIR, PhysicalOperation, PlanDecision, PlanOptions, PlanReport, PlanWarning, PlanWarningCode, PostgresColumnType, PostgresOnlyColumnType, ProvenApplyGuard, ProvenGuardProtocol, ProvenPlanShape, ProvenPlanStep, PseudoColumnExpressionIntent, PseudoColumnMetadata, PseudoColumnTraversal, QueryIntent, RangeOperator, RangeValue, RankingWindowFunction, RawExpressionIntent, RawSqlAdapter, RecognitionResult, RecursiveAdvancedOptions, RecursiveDedupe, RecursiveDirection, RecursiveEmitOptions, RecursiveExistsOptions, RecursiveIntent, RecursiveMetadata, RecursiveNodeIdExpr, RecursivePlanOptions, RecursivePlanReport, RecursiveTrackOptions, RecursiveTraversal, RelationColumnIntent, RelationIR, RelationKind, RelationOperator, RelationType, RequiredEnumLabelIR, ResolvedIncludeStrategy, ResourceAddress, RuleEvaluation, RuleSupport, SQLiteColumnType, SelectAggregateIntent, SelectAllIntent, SelectFieldsIntent, SelectIntent, SelectWithExpressionsIntent, SerializedProvenPlan, SortDirection, StepJournal, StreamingAdapter, StringOperator, SubqueryIncludeInfo, SubqueryRefIntent, SupportedColumnTypes, TableIR, TransactionOptions, TransactionalAdapter, TransactionalCompletionRecord, TransitionCandidate, TransitionConnectionPool, TransitionQueryClient, TransitionRule, TransitionRunMetadata, TruncateOptions, UpdateIntent, UpsertConflictAction, UpsertConflictTarget, UpsertFromIntent, UpsertIntent, VacuumOptions, WhereAndIntent, WhereAnyIntent, WhereComparisonIntent, WhereExistsIntent, WhereInIntent, WhereIntent, WhereLikeIntent, WhereNotExistsIntent, WhereNotIntent, WhereNullIntent, WhereOrIntent, WhereRangeIntent, WhereRelationFilterIntent, WhereSubqueryIntent, WindowFunction, WindowIntent, WindowOrderBy, getNodeIdAlias, isAdjacencyTraversal, isAggregateWindowFunction, isCoalesceExpression, isColumnAliasExpression, isCustomTraversal, isDeleteIntent, isEdgeTableTraversal, isInsertIntent, isMutationIntent, isRankingWindowFunction, isRawExpression, isRecursiveIntent, isRelationColumnExpression, isSelectAggregate, isSelectAll, isSelectFields, isSelectWithExpressions, isSubqueryRef, isUpdateIntent, isUpsertIntent, isWhereAnd, isWhereAny, isWhereComparison, isWhereExists, isWhereIn, isWhereLike, isWhereLogical, isWhereNot, isWhereNotExists, isWhereNull, isWhereOr, isWhereRange, isWhereRelationBased, isWhereRelationFilter, isWhereSubquery, isWindowIntent } from '@dbsp/types';
 import { NqlCompilerOptions } from '@dbsp/nql';
 
 /**
@@ -560,11 +560,15 @@ declare function isAliasedColumn(value: unknown): value is AliasedColumn<string,
  * Matches SchemaColumnType from schema.ts.
  */
 type SchemaColumnType$1 = 'string' | 'text' | 'uuid' | 'number' | 'integer' | 'decimal' | 'bigint' | 'boolean' | 'date' | 'time' | 'datetime' | 'timestamp' | 'json' | 'jsonb' | 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange';
+/** JavaScript read-side representation for PostgreSQL bigint/int8 values. */
+type ColumnJsReadType = 'bigint' | 'number' | 'string';
 /**
  * Column definition - short form or long form.
  */
 type ColumnDef$1 = SchemaColumnType$1 | {
     type: SchemaColumnType$1;
+    dbType?: string;
+    js?: ColumnJsReadType;
     nullable?: boolean;
     unique?: boolean;
     primaryKey?: boolean;
@@ -587,6 +591,7 @@ interface RefOptionsShape {
     inverse?: string;
     nullable?: boolean;
     unique?: boolean;
+    js?: ColumnJsReadType;
     onDelete?: string;
     onUpdate?: string;
     roles?: unknown;
@@ -609,27 +614,57 @@ type IsRef<T> = T extends {
  * Extract the column type from a ColumnDef.
  */
 type ExtractColumnType$1<C> = C extends SchemaColumnType$1 ? C : C extends {
-    type: infer T extends SchemaColumnType$1;
+    readonly type: infer T extends SchemaColumnType$1;
 } ? T : never;
 /**
  * Check if a column is nullable.
  */
 type IsNullable$1<C> = C extends {
-    nullable: true;
+    readonly nullable: true;
 } ? true : false;
 /**
  * Map schema column types to TypeScript types.
  */
 type MapColumnTypeToTS<T extends SchemaColumnType$1> = T extends 'string' | 'text' | 'uuid' ? string : T extends 'number' | 'integer' | 'decimal' ? number : T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'date' | 'time' | 'datetime' | 'timestamp' ? Date : T extends 'json' | 'jsonb' ? unknown : T extends 'daterange' | 'tsrange' | 'tstzrange' | 'int4range' | 'int8range' | 'numrange' ? unknown : unknown;
 /**
- * Infer the TypeScript type for a column definition.
+ * Infer the non-null TypeScript type for a column definition.
+ */
+type InferColumnNonNullTSType<C extends ColumnDef$1> = ExtractColumnType$1<C> extends 'bigint' ? C extends {
+    readonly js: 'number';
+} ? number : C extends {
+    readonly js: 'bigint';
+} ? bigint : C extends {
+    readonly js: 'string';
+} ? string : MapColumnTypeToTS<ExtractColumnType$1<C>> : MapColumnTypeToTS<ExtractColumnType$1<C>>;
+/**
+ * Infer the non-null TypeScript type for a ref-backed FK column.
+ */
+type InferRefColumnNonNullTSType<R extends RefDefinition$1> = R extends {
+    readonly options: {
+        readonly js: 'number';
+    };
+} ? number : R extends {
+    readonly options: {
+        readonly js: 'bigint';
+    };
+} ? bigint : R extends {
+    readonly options: {
+        readonly js: 'string';
+    };
+} ? string : number | string;
+/**
+ * Infer the TypeScript type for a column or ref-backed FK definition.
  */
-type InferColumnTSType<C> = IsRef<C> extends true ? never : C extends ColumnDef$1 ? IsNullable$1<C> extends true ? MapColumnTypeToTS<ExtractColumnType$1<C>> | null : MapColumnTypeToTS<ExtractColumnType$1<C>> : never;
+type InferColumnTSType<C> = C extends RefDefinition$1 ? C extends {
+    readonly options: {
+        readonly nullable: true;
+    };
+} ? InferRefColumnNonNullTSType<C> | null : InferRefColumnNonNullTSType<C> : C extends ColumnDef$1 ? IsNullable$1<C> extends true ? InferColumnNonNullTSType<C> | null : InferColumnNonNullTSType<C> : never;
 /**
- * Extract only column definitions (not refs) from a TableDef.
+ * Extract user-visible column definitions, including ref-backed FK columns.
  */
 type ExtractColumns<T extends TableDef$1> = {
-    [K in keyof T as IsRef<T[K]> extends true ? never : K]: T[K];
+    [K in keyof T as T[K] extends ColumnDef$1 | RefDefinition$1 ? K : never]: T[K];
 };
 /**
  * Extract only ref definitions from a TableDef.
@@ -740,6 +775,7 @@ type SchemaColumnType = ColumnType;
  */
 type ColumnDef = SchemaColumnType | {
     type: SchemaColumnType;
+    js?: ColumnJsReadType$1;
     dbType?: string;
     nullable?: boolean;
     unique?: boolean;
@@ -772,6 +808,8 @@ interface RefOptions {
     nullable?: boolean;
     /** Is this FK unique? → 1:1 instead of 1:N */
     unique?: boolean;
+    /** Optional read-side JavaScript representation for bigint/int8 FK columns */
+    js?: ColumnJsReadType$1;
     /** ON DELETE action */
     onDelete?: OnDeleteAction;
     /** ON UPDATE action */
@@ -1045,19 +1083,30 @@ type InferColumnType<T extends SchemaColumnType> = T extends 'string' | 'text' |
  * Extracts the type string from a ColumnDef (handles short and long forms).
  */
 type ExtractColumnType<C extends ColumnDef> = C extends SchemaColumnType ? C : C extends {
-    type: infer T extends SchemaColumnType;
+    readonly type: infer T extends SchemaColumnType;
 } ? T : never;
 /**
  * Checks if a ColumnDef is nullable.
  */
 type IsNullable<C extends ColumnDef> = C extends {
-    nullable: true;
+    readonly nullable: true;
 } ? true : false;
+/**
+ * Infers the non-null TypeScript type for a single column definition.
+ * Bigint keeps its existing default type unless an explicit read-side js type is set.
+ */
+type InferColumnNonNull<C extends ColumnDef> = ExtractColumnType<C> extends 'bigint' ? C extends {
+    readonly js: 'number';
+} ? number : C extends {
+    readonly js: 'bigint';
+} ? bigint : C extends {
+    readonly js: 'string';
+} ? string : InferColumnType<ExtractColumnType<C>> : InferColumnType<ExtractColumnType<C>>;
 /**
  * Infers the TypeScript type for a single column definition.
  * Handles both short form ('string') and long form ({ type: 'string', nullable: true }).
  */
-type InferColumn<C extends ColumnDef> = IsNullable<C> extends true ? InferColumnType<ExtractColumnType<C>> | null : InferColumnType<ExtractColumnType<C>>;
+type InferColumn<C extends ColumnDef> = IsNullable<C> extends true ? InferColumnNonNull<C> | null : InferColumnNonNull<C>;
 /**
  * Infers the FK column type from a RefDefinition.
  *
@@ -1079,11 +1128,24 @@ type InferColumn<C extends ColumnDef> = IsNullable<C> extends true ? InferColumn
  * authorId: ref('users')                        // Type: number | string
  * editorId: ref('users', { nullable: true })    // Type: number | string | null
  */
+type InferRefColumnNonNull<R extends RefDefinition> = R extends {
+    readonly options: {
+        readonly js: 'number';
+    };
+} ? number : R extends {
+    readonly options: {
+        readonly js: 'bigint';
+    };
+} ? bigint : R extends {
+    readonly options: {
+        readonly js: 'string';
+    };
+} ? string : number | string;
 type InferRefColumn<R extends RefDefinition> = R extends {
-    options: {
-        nullable: true;
+    readonly options: {
+        readonly nullable: true;
     };
-} ? number | string | null : number | string;
+} ? InferRefColumnNonNull<R> | null : InferRefColumnNonNull<R>;
 /**
  * Infers the row type for a single table definition.
  * Maps each column to its TypeScript type.
@@ -1141,7 +1203,7 @@ type InferSchemaDB<S extends Schema<SchemaDefinition>> = S extends Schema<infer
  * parentId: ref('categories', { roles: { parent: 'parent', children: 'children' } })
  * ```
  */
-declare function ref$1<TTarget extends string, TOptions extends RefOptions = Record<string, never>>(target: TTarget, options?: TOptions): RefDefinition<TTarget, TOptions>;
+declare function ref$1<const TTarget extends string, const TOptions extends RefOptions = Record<string, never>>(target: TTarget, options?: TOptions): RefDefinition<TTarget, TOptions>;
 /**
  * Type guard for RefDefinition.
  */
@@ -1170,7 +1232,7 @@ declare function isRef(value: ColumnDef | RefDefinition): value is RefDefinition
  * const orm = createOrm({ model: db.model, adapter });
  * ```
  */
-declare function schema<T extends SchemaDefinition>(definition: T, constraints?: SchemaConstraints, options?: SchemaOptions, extras?: SchemaExtras): Schema<T>;
+declare function schema<const T extends SchemaDefinition>(definition: T, constraints?: SchemaConstraints, options?: SchemaOptions, extras?: SchemaExtras): Schema<T>;
 /**
  * Validation error during schema conversion.
  */
@@ -1334,6 +1396,337 @@ declare class UnsupportedStrategyError extends Error {
     constructor(message: string);
 }
 
+type ObservationContextMergeResult = {
+    readonly ok: true;
+    readonly context: ObservationContext;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+
+interface OperationFingerprints {
+    readonly expectedBefore: FingerprintManifest;
+    readonly expectedAfter: FingerprintManifest;
+}
+interface RegisteredOperationSemantics extends OperationSemantics {
+    readonly operationKind?: OperationKindRef;
+    supportsOperation?(operation: PhysicalOperation): boolean;
+    buildFingerprints(operation: PhysicalOperation, evidence: readonly EvidenceObservation[], context: ObservationContext): OperationFingerprints;
+}
+interface OperationObservation {
+    readonly observations: readonly IssuedObservation[];
+    readonly fingerprint: FingerprintManifest;
+}
+interface ComparatorNameNormalizer {
+    /**
+     * Normalize identifiers from the observed/current model into the namespace
+     * used by authored desired models before comparator matching runs.
+     */
+    normalizeCurrentIdentifier(identifier: string): string;
+}
+interface CompositionFactSatisfactionOwner {
+    readonly compositionFactKinds: readonly string[];
+    satisfiesCompositionFact(fact: TransitionCompositionFact, current: ModelIR, context: ObservationContext): boolean;
+}
+type RulePrecedenceFact = {
+    readonly higher: RuleRef;
+    readonly lower: RuleRef;
+    readonly reason: string;
+};
+interface GuardExecutionResult {
+    readonly passed: boolean;
+    readonly observations: readonly IssuedObservation[];
+    readonly recovery: readonly RecoveryArtefact[];
+}
+interface TransitionExecutionClient {
+    readonly opaqueClient: unknown;
+}
+interface NonRollbackableExecutionTracker {
+    markNonRollbackableOperationExecuted(): void;
+}
+interface ExecutionCoordinator {
+    readonly transactionDomain: string;
+    checkout(target: TransitionConnectionPool): Promise<TransitionExecutionClient>;
+    release(client: TransitionExecutionClient, error?: unknown): Promise<void> | void;
+    begin(client: TransitionExecutionClient): Promise<void>;
+    setLockTimeout(client: TransitionExecutionClient, maxWaitMs: number): Promise<void>;
+    commit(client: TransitionExecutionClient): Promise<void>;
+    rollback(client: TransitionExecutionClient): Promise<void>;
+    isLockTimeout(error: unknown): boolean;
+}
+interface TransactionCoordinatorBinding {
+    readonly coordinator: ExecutionCoordinator;
+    readonly transactionDomain: string;
+}
+interface OperationRuntime extends RegisteredOperationSemantics {
+    checkout(target: TransitionConnectionPool): Promise<TransitionExecutionClient>;
+    release(client: TransitionExecutionClient, error?: unknown): Promise<void> | void;
+    writeIntentJournal(client: TransitionExecutionClient, record: DurableIntentRecord): Promise<void>;
+    begin(client: TransitionExecutionClient): Promise<void>;
+    setLockTimeout(client: TransitionExecutionClient, maxWaitMs: number): Promise<void>;
+    acquireLocks(client: TransitionExecutionClient, operation: PhysicalOperation, effects: OperationEffectAssessment, context: ObservationContext): Promise<void>;
+    observeContext(client: TransitionExecutionClient, operation: PhysicalOperation, proofContext: ObservationContext): Promise<ObservationContext>;
+    observeOperation(client: TransitionExecutionClient, operation: PhysicalOperation, context: ObservationContext, phase: 'before' | 'after', issuer: ObservationIssuer): Promise<OperationObservation>;
+    checkGuard(client: TransitionExecutionClient, operation: PhysicalOperation, guard: ApplyGuard, context: ObservationContext): Promise<GuardExecutionResult>;
+    executeOperation(client: TransitionExecutionClient, operation: PhysicalOperation, context: ObservationContext, duringGuards?: readonly ApplyGuard[], executionTracker?: NonRollbackableExecutionTracker): Promise<OperationExecutionOutcome>;
+    writeCompletionJournal(client: TransitionExecutionClient, operation: PhysicalOperation, record: TransactionalCompletionRecord): Promise<void>;
+    commit(client: TransitionExecutionClient): Promise<void>;
+    rollback(client: TransitionExecutionClient): Promise<void>;
+    writeObservedJournal(client: TransitionExecutionClient, journal: StepJournal): Promise<void>;
+    isLockTimeout(error: unknown): boolean;
+}
+interface TransitionPack {
+    readonly rules: readonly TransitionRule[];
+    readonly operationSemantics: readonly RegisteredOperationSemantics[];
+    readonly issuer: ObservationIssuer;
+    readonly executionCoordinator?: ExecutionCoordinator;
+    readonly transactionDomain?: string;
+    readonly equivalence?: EquivalenceCapability;
+    readonly capabilityDescriptors?: readonly CapabilityDescriptor[];
+    readonly comparatorNameNormalizer?: ComparatorNameNormalizer;
+    readonly compositionFactKinds?: CompositionFactSatisfactionOwner['compositionFactKinds'];
+    readonly satisfiesCompositionFact?: CompositionFactSatisfactionOwner['satisfiesCompositionFact'];
+    readonly rulePrecedence?: readonly RulePrecedenceFact[];
+}
+type OperationResolution = {
+    readonly ok: true;
+    readonly semantics: RegisteredOperationSemantics;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+declare function serverVersionNum(engineVersion: string): number | undefined;
+declare function isOperationRuntime(semantics: RegisteredOperationSemantics): semantics is OperationRuntime;
+type RulePrecedenceResolution = {
+    readonly ok: true;
+    readonly rule: TransitionRule;
+    readonly facts: readonly RulePrecedenceFact[];
+    readonly reason: string;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+declare class PackRegistry {
+    private readonly rules;
+    private readonly operationSemantics;
+    private readonly issuers;
+    private readonly rulePrecedence;
+    private readonly issuerByArtifact;
+    private readonly equivalenceByArtifact;
+    private readonly compositionFactOwnerByKind;
+    private readonly capabilityDescriptors;
+    private readonly nameNormalizer;
+    private readonly privilegeMergers;
+    private readonly transactionCoordinatorBySemantics;
+    constructor(packs: readonly TransitionPack[]);
+    allRules(): readonly TransitionRule[];
+    defaultIssuer(): ObservationIssuer | undefined;
+    comparatorNameNormalizer(): ComparatorNameNormalizer | undefined;
+    resolveRule(ref: RuleRef): TransitionRule | undefined;
+    resolveRulePrecedence(rules: readonly TransitionRule[]): RulePrecedenceResolution;
+    resolveIssuer(ref?: SemanticArtifactRef): ObservationIssuer | undefined;
+    resolveEquivalence(ref?: SemanticArtifactRef): EquivalenceCapability | undefined;
+    contextWithDerivedCapabilities(context: ObservationContext): ObservationContext;
+    mergeObservationContexts(left: ObservationContext, right: ObservationContext): ObservationContextMergeResult;
+    satisfiesCompositionFact(fact: Parameters<CompositionFactSatisfactionOwner['satisfiesCompositionFact']>[0], current: ModelIR, context: ObservationContext): boolean;
+    resolveOperation(operation: PhysicalOperation): OperationResolution;
+    transactionCoordinatorFor(semantics: RegisteredOperationSemantics): TransactionCoordinatorBinding | undefined;
+}
+declare function createPackRegistry(packs: readonly TransitionPack[]): PackRegistry;
+
+declare function createApplier(registry: PackRegistry): Applier;
+
+type CheckSetEntry = Pick<CheckConstraintIR, 'name' | 'expression' | 'notValid'>;
+type CheckDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-check';
+    readonly check: CheckSetEntry;
+    readonly expectedBefore: readonly CheckSetEntry[];
+    readonly expectedAfter: readonly CheckSetEntry[];
+} | {
+    readonly kind: 'expression-mismatch';
+    readonly desired: CheckSetEntry;
+    readonly current: CheckSetEntry;
+    readonly expectedBefore: readonly CheckSetEntry[];
+    readonly expectedAfter: readonly CheckSetEntry[];
+} | {
+    readonly kind: 'unsupported';
+};
+declare function checkDelta(desiredChecks: readonly CheckConstraintIR[] | undefined, currentChecks: readonly CheckConstraintIR[] | undefined): CheckDelta;
+
+declare function createComparator(registry: PackRegistry): Comparator;
+
+type EnumAddDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-label';
+    readonly label: string;
+    readonly after?: string;
+} | {
+    readonly kind: 'unsupported';
+};
+interface EnumAddDeltaOptions {
+    readonly targetSchema?: string;
+}
+declare function resolveEnumSchemaForComparison(enumDef: EnumIR, targetSchema?: string): EnumIR;
+declare function enumAddDelta(desired: EnumIR, current: EnumIR, options?: EnumAddDeltaOptions): EnumAddDelta;
+
+declare function createEvidenceView(params: {
+    readonly evidence: readonly EvidenceObservation[];
+    readonly context: ObservationContext;
+    readonly requests?: readonly ObservationRequest[];
+}): EvidenceView;
+
+declare function semanticArtifactId(value: string): SemanticArtifactId;
+declare function assumptionId(value: string): AssumptionId;
+declare function claimId(value: string): ClaimId;
+declare function evidenceId(value: string): EvidenceId;
+declare function advisoryObservationId(value: string): AdvisoryObservationId;
+
+type IndexSetEntry = {
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    readonly valid?: boolean;
+    readonly ready?: boolean;
+    readonly method?: string;
+    readonly where?: string;
+    readonly expressions?: readonly string[];
+    readonly include?: readonly string[];
+    readonly opclass?: Readonly<Record<string, string>>;
+    readonly with?: Readonly<Record<string, string>>;
+    readonly nullsNotDistinct?: boolean;
+};
+type IndexDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-unique-index';
+    readonly index: IndexSetEntry;
+    readonly expectedBefore: readonly IndexSetEntry[];
+    readonly expectedAfter: readonly IndexSetEntry[];
+} | {
+    readonly kind: 'unsupported';
+};
+declare function defaultIndexName(tableName: string, index: Pick<IndexIR, 'name' | 'columns'>): string;
+type IndexPerspective = 'desired' | 'current';
+declare function normalizedIndex(tableName: string, index: IndexIR, perspective?: IndexPerspective): IndexSetEntry;
+declare function indexDelta(tableName: string, desiredIndexes: readonly IndexIR[], currentIndexes: readonly IndexIR[]): IndexDelta;
+
+declare function createProver(registry: PackRegistry): Prover;
+
+declare function resourceIsWithin(resource: ResourceAddress, parent: ResourceAddress): boolean;
+declare function selectorMatchesResource(selector: ResourceSelector, resource: ResourceAddress): boolean;
+declare function resourceScopeCovers(scope: readonly ResourceAddress[], required: readonly ResourceAddress[]): boolean;
+
+interface StagedTransitionInput {
+    readonly desired: ModelIR;
+    readonly loadCurrent: () => Promise<ModelIR>;
+    readonly readContext: () => Promise<ObservationContext>;
+    readonly target: TransitionConnectionPool;
+    readonly policy: ApplyPolicy;
+    readonly maxIterations?: number;
+}
+interface StagedTransitionOrchestrator {
+    applyStagedTransition(input: StagedTransitionInput): Promise<ApplyResult>;
+}
+declare function createStagedTransitionOrchestrator(registry: PackRegistry): StagedTransitionOrchestrator;
+
+type TransitionCompare = Extract<CompareOutcome, {
+    readonly kind: 'transitions';
+}>;
+interface StagedCompositionCandidate {
+    readonly candidate: TransitionCandidate;
+    readonly index: number;
+    readonly composition?: TransitionFragmentComposition;
+    readonly opRefs: readonly string[];
+}
+type StagedCompositionPreflight = {
+    readonly kind: 'provable-in-stages';
+    readonly ready: readonly StagedCompositionCandidate[];
+    readonly pending: readonly StagedCompositionCandidate[];
+    readonly detail?: string;
+} | {
+    readonly kind: 'unsupported-transition';
+    readonly assessment: PlanAssessment;
+};
+interface StagedCompositionPreflightInput {
+    readonly compare: TransitionCompare;
+    readonly current: ModelIR;
+    readonly context: ObservationContext;
+}
+declare function preflightStagedComposition(registry: PackRegistry, input: StagedCompositionPreflightInput): StagedCompositionPreflight;
+declare function chooseReadyCandidate(preflight: Extract<StagedCompositionPreflight, {
+    readonly kind: 'provable-in-stages';
+}>): StagedCompositionCandidate;
+declare function projectCompareToSingleCandidate(compare: TransitionCompare, entry: StagedCompositionCandidate): TransitionCompare;
+
+type TransitionRelationalValidationInput = {
+    readonly kind: 'fragment';
+    readonly fragment: TransitionFragment;
+    readonly claims: readonly ProofClaim[];
+    readonly assumptions: readonly Assumption[];
+} | {
+    readonly kind: 'plan';
+    readonly plan: ProvenPlanShape;
+    readonly operationEffectsByRef?: ReadonlyMap<string, OperationEffectAssessment>;
+};
+type TransitionRelationalValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+/**
+ * Diagnostic consistency check for transition fragments and already-trusted,
+ * in-process plans. For plan inputs this is not an untrusted serialized-plan
+ * validator; apply() first requires the module-private minting capability, and
+ * any later plan failure is a prover bug.
+ */
+declare function validateTransitionRelationalInvariants(input: TransitionRelationalValidationInput): TransitionRelationalValidationResult;
+
+type InProcessProvenPlan = ProvenPlanShape & {
+    readonly __inProcessProvenPlan: unique symbol;
+};
+type EstablishedProofClaim = ProofClaim & {
+    readonly assumes: readonly [];
+    readonly derivedBy: {
+        readonly conclusion: 'established';
+    };
+};
+type ProveOutcome = {
+    readonly kind: 'proven';
+    readonly plan: InProcessProvenPlan;
+    readonly assessment: ApplicableAssessment;
+} | {
+    readonly kind: 'no-drift';
+    readonly claim: EstablishedProofClaim;
+    readonly assessment: ApplicableAssessment;
+} | {
+    readonly kind: 'blocked';
+    readonly assessment: PlanAssessment;
+} | {
+    readonly kind: 'inapplicable';
+    readonly assessment: InapplicableAssessment;
+    readonly claim?: ProofClaim;
+};
+interface Prover {
+    readonly artifact: SemanticArtifactRef;
+    prove(compare: CompareOutcome, target: TransitionConnectionPool, context: ObservationContext): Promise<ProveOutcome>;
+}
+interface Applier {
+    readonly artifact: SemanticArtifactRef;
+    apply(proven: {
+        readonly plan: InProcessProvenPlan;
+        readonly assessment: ApplicableAssessment;
+    }, policy: ApplyPolicy, target: TransitionConnectionPool): Promise<ApplyResult>;
+    resume(runId: string, loadCurrent: TransitionResumeJournalLoader, readContext: TransitionResumeContextReader, policy: ApplyPolicy, target: TransitionConnectionPool): Promise<ApplyResult>;
+}
+type TransitionResumeJournalLoader = (runId: string) => Promise<TransitionRunJournal & {
+    readonly plan: ProvenPlanShape;
+}>;
+type TransitionResumeContextReader = (target: TransitionConnectionPool, run: TransitionRunJournal['run']) => Promise<ObservationContext>;
+
 /**
  * @module model-impl
  * ModelIR implementation with Map-based storage and helper methods.
@@ -2033,7 +2426,7 @@ interface QueryBuilderContext {
  * Options for streaming query execution.
  * Options for configuring streaming behavior.
  */
-interface StreamOptions {
+interface StreamOptions extends TransactionBeginOptions {
     /**
      * Number of rows to fetch per batch from the database.
      * Only affects PostgreSQL with pg-cursor configured.
@@ -2045,6 +2438,8 @@ interface StreamOptions {
      * Receives the query dump for observability/logging.
      */
     readonly onStart?: (dump: Dump) => void;
+    /** AbortSignal is intentionally unsupported by stream-owned transactions. */
+    readonly signal?: never;
 }
 /**
  * Options for offset-based pagination.
@@ -3330,9 +3725,10 @@ declare class CteBuilder {
     private readonly cteName;
     private readonly adapter;
     private readonly schemaName;
+    private readonly model;
     private unnestColumns;
     private indexColumnName;
-    constructor(name: string, adapter?: Adapter, schemaName?: string);
+    constructor(name: string, adapter?: Adapter, schemaName?: string, model?: ModelIR);
     /**
      * Provide the column arrays for the unnest() CTE.
      * All arrays must have the same length.
@@ -3371,12 +3767,14 @@ declare class CteQueryBuilder<TResult = unknown> {
     private readonly outerBuilder;
     private readonly adapter;
     private readonly schemaName;
-    constructor(cteIntent: UnnestCteIntent, outerBuilder: QueryBuilderImpl<TResult>, adapter?: Adapter, schemaName?: string);
+    private readonly model;
+    constructor(cteIntent: UnnestCteIntent, outerBuilder: QueryBuilderImpl<TResult>, adapter?: Adapter, schemaName?: string, model?: ModelIR);
     /**
      * Build the CteQueryIntent AST.
      */
     buildIntent(): CteQueryIntent;
     private requireAdapter;
+    private compileOptions;
     /**
      * Compile to SQL and return an observability dump.
      */
@@ -3455,6 +3853,7 @@ declare abstract class MutationBuilderBase<T, TIntent extends InsertIntent | Upd
     protected requireAdapter(operation: string): Adapter;
     dump(extraOptions?: CompileOptions): MutationDump;
     execute(): Promise<T>;
+    affectedRows(): Promise<number>;
     private prepareMutationExecution;
 }
 /**
@@ -3816,12 +4215,13 @@ declare class RawCteQueryBuilder<TResult = unknown> {
     private readonly rawCteIntent;
     private readonly adapter;
     private readonly schemaName;
+    private readonly model;
     private outerSelect;
     private outerWhere;
     private outerOrderBy;
     private outerLimit;
     private outerOffset;
-    constructor(cteName: string, rawCteIntent: RawCteIntent, adapter?: Adapter, schemaName?: string);
+    constructor(cteName: string, rawCteIntent: RawCteIntent, adapter?: Adapter, schemaName?: string, model?: ModelIR);
     /**
      * Select specific columns from the CTE result.
      */
@@ -3863,7 +4263,7 @@ declare class RawCteQueryBuilder<TResult = unknown> {
 /**
  * Create a RawCteQueryBuilder from named builder instances.
  */
-declare function createRawCteBuilder<TResult = unknown>(cteName: string, options: RecursiveOptions, adapter?: Adapter, schemaName?: string): RawCteQueryBuilder<TResult>;
+declare function createRawCteBuilder<TResult = unknown>(cteName: string, options: RecursiveOptions, adapter?: Adapter, schemaName?: string, model?: ModelIR): RawCteQueryBuilder<TResult>;
 
 /**
  * Type definitions for table-scoped DDL operations.
@@ -4078,6 +4478,13 @@ interface SelectExpressionResult {
      */
     execute<T = Record<string, unknown>>(): Promise<T[]>;
 }
+interface RawReadOptions {
+    /**
+     * Map of output-key -> JS read type, applied to bigint columns read via raw SQL.
+     * The caller declares provenance explicitly; dbsp does not infer it for arbitrary SQL.
+     */
+    readonly bigintReads?: Readonly<Record<string, ColumnJsReadType$1>>;
+}
 interface OrmInstance<DB = Record<string, unknown>> {
     /**
      * Type-safe table references for query building.
@@ -4227,6 +4634,26 @@ interface OrmInstance<DB = Record<string, unknown>> {
      * The strict mode setting for this ORM instance.
      */
     readonly strictMode: boolean;
+    /**
+     * Whether the connection backing this ORM instance is inside a transaction.
+     *
+     * Reflects the backing adapter's real transaction state: `true` inside a
+     * {@link OrmInstance.transaction} callback, and also `true` for a top-level
+     * instance built on an adapter that is ALREADY inside a caller-owned
+     * transaction (e.g. a borrowed pg client mid-`BEGIN`); `false` otherwise.
+     *
+     * Callers use this to enforce a top-level precondition: an operation whose
+     * effects a caller's outer rollback must not silently undo — DDL that cannot
+     * be nested, or a process-level cache that would go stale if the surrounding
+     * transaction rolls back — can fail closed when the connection is already in a
+     * transaction instead of assuming it owns the top-level transaction.
+     *
+     * Optional for backward compatibility: instances produced by `createOrm`
+     * always populate it, but a pre-existing hand-built `OrmInstance` double may
+     * omit it (reads as `undefined`), so a fail-closed caller should treat a
+     * non-`true` value it cannot confirm accordingly.
+     */
+    readonly inTransaction?: boolean;
     /**
      * Create a schema-scoped ORM instance.
      * All queries from the returned instance will include the schema prefix.
@@ -4334,7 +4761,17 @@ interface OrmInstance<DB = Record<string, unknown>> {
      * });
      * ```
      */
-    transaction<T>(fn: (tx: OrmInstance<DB>) => Promise<T>): Promise<T>;
+    transaction<T>(fn: (tx: OrmInstance<DB>) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Execute a callback with all ORM work pinned to one physical database
+     * connection for the callback lifetime, without opening a transaction.
+     *
+     * @typeParam T - The return type of the callback
+     * @param fn - Async callback that receives a connection-pinned ORM instance
+     * @param options - Optional pinned connection controls
+     * @returns Promise resolving to the callback's return value
+     */
+    withPinnedConnection<T>(fn: (pinned: OrmInstance<DB>) => Promise<T>, options?: PinnedConnectionOptions): Promise<T>;
     /**
      * NQL template tag for writing queries in Natural Query Language.
      *
@@ -4358,9 +4795,10 @@ interface OrmInstance<DB = Record<string, unknown>> {
      * @typeParam T - Expected result type (defaults to unknown)
      * @param sql - Raw SQL string with parameter placeholders
      * @param parameters - Parameter values for placeholders
+     * @param options - Explicit raw read coercion options
      * @returns Promise resolving to array of results
      */
-    raw<T = unknown>(sql: string, parameters?: readonly unknown[]): Promise<T[]>;
+    raw<T = unknown>(sql: string, parameters?: readonly unknown[], options?: RawReadOptions): Promise<T[]>;
     /**
      * Create a CTE (Common Table Expression) backed by unnest() arrays.
      *
@@ -6348,7 +6786,7 @@ interface FeatureUsage {
     readonly detail: string;
 }
 /**
- * Default feature checkers -- mirrors the 16 supportsDDL* flags that
+ * Default feature checkers -- mirrors the 17 supportsDDL* flags that
  * negotiateFeatures() previously checked inline.
  *
  * Each checker preserves exactly the same detection logic (same guards,
@@ -7275,7 +7713,7 @@ declare class ResultHydrator<TResult = unknown> {
      * E2E-004: json_agg strategy returns data as JSON string in *_json columns.
      * STRAT-SIMPLIFY: For to-one relations (belongsTo/hasOne), unwrap array to single object.
      */
-    hydrateJsonAggIncludes(results: TResult[], planReport: PlanReport): void;
+    hydrateJsonAggIncludes(results: TResult[], planReport: PlanReport, query?: CompiledQuery): void;
     /**
      * Process recursive includes via CTEs.
      */
@@ -7619,4 +8057,4 @@ declare const assertIntentHasOrderBy: (result: AssertionQueryResult, expected: b
  */
 declare function runAssertions(blocks: AssertionBlock[], results: AssertionQueryResult[], queries: string[], hasDb?: boolean): AssertionSummary;
 
-export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, type EmitWarningOptions, ErrorCode, type ErrorHookContext, Errors, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GetSchemaFromDbOptions, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type IncludeOptions, type IncludeOptionsWithRecursive, type InferColumn, type InferColumnType, type InferColumnTypes, type InferDB, type InferRefColumn, type InferRow, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType as NewSchemaColumnType, NotFoundError, type NqlBuilder, type NqlRawFragment, type NqlTag, type OnErrorHook, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, POSTGRESQL_CAPABILITIES, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationPathIncludeNode, type RelationPathUsage, type RelationRef, type RelationShorthand, type RelationTupleDef, ResultHydrator, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaColumnType, type SchemaConstraints, type SchemaDefinition, SchemaValidationError as SchemaError, type SchemaExtras, type SchemaIndexOptions, type SchemaIndexValidationInput, type SchemaOptions, type SchemaTableOptions, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type WarningCategory, type WhereFilter, WindowBuilder, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, batchValues, capitalize, caseWhen, cast, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, countDistinctRelationPathsByName, createDialectCapabilities, createHookManager, createNqlTag, createOrm, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, decapitalize, defaultLogger, defineModel, denseRank, deriveRelationPathFromIntentPath, distinct, emitWarning, eq, every, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, inferForeignKey, isAliasedColumn, isAllColumns, isBatchValuesRef, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isKnownDialect, isNotNull, isNull, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, not, notExists, nqlRaw, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveQueryIndex, rowNumber, runAssertions, schema, schemaToModelIR, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, validateSchemaIndexOptions, validateTypeName, wAvg, wCount, wMax, wMin, wSum, withPriority };
+export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Applier, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type CheckDelta, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, type EmitWarningOptions, type EnumAddDelta, ErrorCode, type ErrorHookContext, Errors, type EstablishedProofClaim, type ExecutionCoordinator, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GetSchemaFromDbOptions, type GuardExecutionResult, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type InProcessProvenPlan, type IncludeOptions, type IncludeOptionsWithRecursive, type IndexDelta, type IndexSetEntry, type InferColumn, type InferColumnNonNull, type InferColumnType, type InferColumnTypes, type InferDB, type InferRefColumn, type InferRow, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType as NewSchemaColumnType, type NonRollbackableExecutionTracker, NotFoundError, type NqlBuilder, type NqlRawFragment, type NqlTag, type OnErrorHook, type OperationFingerprints, type OperationObservation, type OperationRuntime, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, POSTGRESQL_CAPABILITIES, PackRegistry, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type ProveOutcome, type Prover, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RegisteredOperationSemantics, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationPathIncludeNode, type RelationPathUsage, type RelationRef, type RelationShorthand, type RelationTupleDef, ResultHydrator, type RulePrecedenceFact, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaColumnType, type SchemaConstraints, type SchemaDefinition, SchemaValidationError as SchemaError, type SchemaExtras, type SchemaIndexOptions, type SchemaIndexValidationInput, type SchemaOptions, type SchemaTableOptions, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StagedCompositionCandidate, type StagedCompositionPreflight, type StagedCompositionPreflightInput, type StagedTransitionInput, type StagedTransitionOrchestrator, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TransactionCoordinatorBinding, type TransitionExecutionClient, type TransitionPack, type TransitionRelationalValidationInput, type TransitionRelationalValidationResult, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type WarningCategory, type WhereFilter, WindowBuilder, advisoryObservationId, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, assumptionId, batchValues, capitalize, caseWhen, cast, checkDelta, chooseReadyCandidate, claimId, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, countDistinctRelationPathsByName, createApplier, createComparator, createDialectCapabilities, createEvidenceView, createHookManager, createNqlTag, createOrm, createPackRegistry, createProver, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, createStagedTransitionOrchestrator, decapitalize, defaultIndexName, defaultLogger, defineModel, denseRank, deriveRelationPathFromIntentPath, distinct, emitWarning, enumAddDelta, eq, every, evidenceId, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, indexDelta, inferForeignKey, isAliasedColumn, isAllColumns, isBatchValuesRef, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isKnownDialect, isNotNull, isNull, isOperationRuntime, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, normalizedIndex, not, notExists, nqlRaw, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, preflightStagedComposition, projectCompareToSingleCandidate, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveEnumSchemaForComparison, resolveQueryIndex, resourceIsWithin, resourceScopeCovers, rowNumber, runAssertions, schema, schemaToModelIR, selectorMatchesResource, semanticArtifactId, serverVersionNum, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, validateSchemaIndexOptions, validateTransitionRelationalInvariants, validateTypeName, wAvg, wCount, wMax, wMin, wSum, withPriority };