@vibeorm/runtime 2.6.0 → 3.0.0

package/dist/adapter-kit/transaction-outcome.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Transaction outcome reports — what a FAILED top-level transaction did and
+ * did not do (EPIC T).
+ *
+ * ONE copy, shared by every adapter package through the
+ * `@vibeorm/runtime/adapter-kit` subpath (like `transaction-budget.ts`), so the
+ * rule cannot drift into a per-engine difference.
+ *
+ * THE RULE
+ *
+ * The commit outcome follows from how far the adapter's OWN `COMMIT` got —
+ * never from the type of the error that ended the transaction:
+ *
+ * - `"not-committed"`: `COMMIT` never left the client (the callback failed, a
+ *   deadline or a closed handle refused it, or the driver had already seen the
+ *   connection die and refused it locally), or the engine ANSWERED it with an
+ *   error or a ROLLBACK tag. Only this session can send `COMMIT`, and a
+ *   server ends an open transaction when its connection closes, so a failed
+ *   cleanup `ROLLBACK` does not change this.
+ * - `"unknown"`: a `COMMIT` that left the client got no answer — the
+ *   connection was lost while it was in flight, or a client-side deadline
+ *   stopped waiting for it. Also when the savepoint stack was lost before
+ *   `COMMIT` (`savepoint-rollback-failed`): an implicit commit (MySQL DDL) or a
+ *   raw `COMMIT` may already have ended the transaction.
+ * - `"committed"`: the engine acknowledged `COMMIT`. A successful transaction
+ *   throws nothing, so no report is recorded for it.
+ *
+ * The cleanup is reported APART from the commit outcome: whether the cleanup
+ * `ROLLBACK` was acknowledged, failed or not needed, and whether the
+ * connection went back to the pool or was discarded.
+ *
+ * WHERE THE FACTS LIVE
+ *
+ * The error a failed transaction throws stays the SAME value — callers match
+ * their own errors and stable codes. The facts ride beside it in a registry
+ * keyed by that value, read with {@link transactionOutcomeOf}. The registry is
+ * a `WeakMap` held on `globalThis` under a `Symbol.for` key: the runtime's
+ * main entry and this subpath are separate bundles, each with its own copy of
+ * this module, and both must read the same map. A `WeakMap` never keeps an
+ * error alive and never changes the error object. Under a frozen or sealed
+ * `globalThis` (SES, hardened JavaScript) the key cannot be added: each copy
+ * then keeps a module-local map, so a report recorded by one bundle is not
+ * visible from the other, and the accessor returns `undefined` — the runtime
+ * stays importable.
+ *
+ * A CROSS-VERSION CONTRACT
+ *
+ * Two installed copies of `@vibeorm/runtime` (an adapter built against one,
+ * a framework reading with another) share the one global map. Each stored
+ * record therefore carries a `version`. The report shape is append-only:
+ * fields are only ever added; a change of meaning bumps the version, and a
+ * reader that does not know a record's version returns `undefined` ("no
+ * facts") rather than misreading it.
+ */
+import { type SavepointScope } from "./savepoint-gate.ts";
+import { type TransactionBudget, type TransactionOutcome } from "./transaction-budget.ts";
+/**
+ * How far an adapter's own `COMMIT` got. The adapter moves it to `"sent"`
+ * IMMEDIATELY before `COMMIT` is handed to the driver, and on a failure
+ * classifies a sent `COMMIT` as `"answered"` (the engine replied with an error
+ * or a ROLLBACK tag) or `"unanswered"` (the reply was lost or abandoned). A
+ * `"sent"` that was never classified counts as unanswered: without an answer
+ * nothing proves that the write did not commit.
+ */
+export type CommitProgress = "not-sent" | "sent" | "answered" | "unanswered";
+/** What the cleanup `ROLLBACK` of a failed top-level transaction did. */
+export type RollbackOutcome = "acknowledged" | "failed" | "not-needed";
+/** Where the transaction's connection went after the failure. */
+export type ConnectionOutcome = "returned" | "discarded";
+/**
+ * The facts of one failed top-level transaction, read with
+ * {@link transactionOutcomeOf}.
+ *
+ * - `commit`: the commit outcome (see the module rule). `"not-committed"` is
+ *   safe to retry as far as the database is concerned; `"unknown"` is not.
+ * - `commitSent`: whether the adapter handed its `COMMIT` to the driver.
+ * - `rollback`: `"acknowledged"` (the engine confirmed the cleanup
+ *   `ROLLBACK`), `"failed"` (it was sent and failed — the connection is lost,
+ *   or the engine refused it), `"not-needed"` (no transaction was open on the
+ *   connection: nothing was sent yet, or the engine had already ended it
+ *   when it answered `COMMIT`).
+ * - `connection`: `"returned"` to the pool (or kept, on a single-connection
+ *   engine) or `"discarded"` (destroyed, so the server ends whatever it still
+ *   holds when it sees the close).
+ */
+export type TransactionOutcomeReport = {
+    readonly commit: FailedCommitOutcome;
+    readonly commitSent: boolean;
+    readonly rollback: RollbackOutcome;
+    readonly connection: ConnectionOutcome;
+};
+/**
+ * The commit outcome of a FAILED transaction. `"committed"` is never recorded:
+ * a transaction that committed throws nothing.
+ */
+export type FailedCommitOutcome = Exclude<TransactionOutcome, "committed">;
+/**
+ * Attach `report` to the value a failed top-level transaction is about to
+ * throw. A later report for the same value replaces the earlier one, so a
+ * value rethrown through several top-level transactions carries the facts of
+ * the LAST one it left. A primitive thrown value (a string, a number,
+ * `undefined`) cannot key a `WeakMap`, so nothing is recorded for it.
+ */
+export declare function recordTransactionOutcome(params: {
+    error: unknown;
+    report: TransactionOutcomeReport;
+}): void;
+/**
+ * The facts of the failed top-level transaction that threw `error`, or
+ * `undefined` when there are none.
+ *
+ * `undefined` means one of: the adapter does not declare
+ * `transactionOutcome: "reported"`; `error` did not leave a top-level
+ * `transaction()` (a nested savepoint records nothing); the transaction was
+ * refused before it started (an invalid option, a connection that could not be
+ * acquired — nothing was sent); the thrown value is not an object (a
+ * primitive cannot key the registry — throw `Error` objects to keep the facts);
+ * the record was written by a runtime copy with a report version this copy
+ * does not know; or `globalThis` is frozen and the report was recorded by the
+ * other bundle (see the module doc).
+ */
+export declare function transactionOutcomeOf(params: {
+    error: unknown;
+}): TransactionOutcomeReport | undefined;
+/** The commit outcome of a failed transaction — the ONE rule (see the module doc). */
+export declare function failedCommitOutcome(params: {
+    commit: CommitProgress;
+    stateLost: boolean;
+}): FailedCommitOutcome;
+/**
+ * Close a failed top-level transaction's budget with its commit outcome (the
+ * rule above) and return that outcome. The first close wins: an adapter that
+ * closed `unknown` the moment it lost a COMMIT reply keeps that.
+ *
+ * {@link settleFailedTransaction} calls it. An adapter whose connection must
+ * leave BEFORE it can settle (adapter-mysql resets the session and releases the
+ * connection to learn where it went) calls it first, so every handle of the
+ * failed transaction is refused before the connection is handed back.
+ */
+export declare function closeFailedTransactionBudget(params: {
+    error: unknown;
+    budget: TransactionBudget;
+    scope: SavepointScope;
+    commit: CommitProgress;
+}): FailedCommitOutcome;
+/**
+ * Settle a failed top-level transaction AFTER its cleanup ran: close the
+ * budget with the commit outcome, choose the value to throw, and record the
+ * facts on it. Returns that value; the adapter throws it.
+ *
+ * The value is `error` itself — the same object, the same code — except when
+ * a client-side deadline abandoned a COMMIT that had already left the client
+ * (`commit: "unanswered"` with the deadline refusal as `error`): only then is
+ * it {@link transactionOutcomeUnknownError}. A deadline that refused the
+ * COMMIT before it was sent is a known outcome (`"not-committed"`), and its own
+ * deadline error is rethrown even when the cleanup `ROLLBACK` failed.
+ */
+export declare function settleFailedTransaction(params: {
+    error: unknown;
+    provider: string;
+    budget: TransactionBudget;
+    scope: SavepointScope;
+    commit: CommitProgress;
+    rollback: RollbackOutcome;
+    connection: ConnectionOutcome;
+}): unknown;
+//# sourceMappingURL=transaction-outcome.d.ts.map

package/dist/adapter.d.ts

@@ -68,12 +68,26 @@ export type TransactionDeadline = {
  * a nested timeout is not enforceable, and a nested deadline would need an
  * independent session setting on a connection it does not own. A nested
  * savepoint instead INHERITS the top-level deadline, by reference.
+ *
+ * `accessMode: "readOnly"` opens a READ ONLY transaction in the opening
+ * statement itself (`BEGIN … READ ONLY` on postgres servers, `START
+ * TRANSACTION READ ONLY` on mysql, `SET TRANSACTION READ ONLY` right after
+ * PGlite's own BEGIN) — no extra round trip. A write inside it is refused by
+ * the engine and raises `VIBE_TRANSACTION` with `meta.reason:
+ * "read-only-transaction"`. sqlite adapters refuse the option with
+ * `VIBE_UNSUPPORTED_CAPABILITY`; a nested call refuses it like the others.
  */
 export type TransactionOptions = {
     isolationLevel?: IsolationLevel;
     timeout?: number;
     deadline?: TransactionDeadline;
+    accessMode?: TransactionAccessMode;
 };
+/**
+ * Transaction access mode. Only `"readOnly"` exists: omitting the option keeps
+ * the engine's default (read/write), exactly as before the option existed.
+ */
+export type TransactionAccessMode = "readOnly";
 /**
  * How far an engine's per-statement timeout actually reaches.
  *
@@ -83,6 +97,15 @@ export type TransactionOptions = {
  * forbids.
  */
 export type StatementTimeoutSupport = "all-statements" | "select-only" | "unsupported";
+/**
+ * Whether a failed top-level `transaction()` reports its facts (EPIC T).
+ * `"reported"`: every object it throws once the transaction has started
+ * carries a `TransactionOutcomeReport`, read with `transactionOutcomeOf({ error })`
+ * from `@vibeorm/runtime` — the commit outcome (`not-committed` / `unknown`),
+ * whether COMMIT was sent, what the cleanup ROLLBACK did and whether the
+ * connection was returned or discarded.
+ */
+export type TransactionOutcomeSupport = "reported";
 /** The strongest transaction-deadline guarantee an adapter can honestly deliver. */
 export type TransactionDeadlineSupport = "cancel-running-statements" | "between-statements" | "unsupported";
 /**
@@ -100,11 +123,35 @@ export type AdapterBudgetSupport = {
     readonly statementTimeout: StatementTimeoutSupport;
     /** What `TransactionOptions.deadline.enforcement` may ask for on this engine. */
     readonly transactionDeadline: TransactionDeadlineSupport;
+    /**
+     * The `TransactionOptions.accessMode` values this adapter honours in its
+     * opening statement. Not a timing budget, but declared here for the same
+     * reason as `transactionDeadline`: the runtime refuses an access mode the
+     * adapter does not declare with `VIBE_UNSUPPORTED_CAPABILITY` before it calls
+     * `transaction()`, so an adapter that predates the option (or a third-party
+     * one) can never open a read/write transaction for a caller who asked for a
+     * read-only one. Optional (additive); undeclared = none.
+     */
+    readonly accessModes?: readonly TransactionAccessMode[];
 };
 /** Surviving direct DML effects, or an honest unknown when observation is incomplete. */
 export type RowChangeCount = number | "unknown";
-/** Internal structured execution intent. Never accepted as an ORM/raw query argument. */
-export type StatementEffect = "read" | "write" | "unknown";
+/**
+ * Internal structured execution intent. Never accepted as an ORM/raw query argument.
+ *
+ * `writeRows` (round-trip campaign EPIC 4): a data-modifying statement chain
+ * whose RESULT ROWS are its direct effects — one returned row per changed row.
+ * An adapter counts the rows it received, never the command tag: a chain's tag
+ * is `SELECT n`, and PGlite reports zero affected rows for any SELECT. An
+ * adapter that cannot count rows reports `unknown` for it.
+ *
+ * `writeTally` (round-trip campaign EPIC F): a statement chain that REPORTS its
+ * direct effects in the result column `ROW_CHANGES_COLUMN` (adapter-kit) — the
+ * rows its data-modifying steps changed, which its result rows do not show.
+ * An adapter sums that column over the rows it received (adapter-kit
+ * `statementRowChanges` with `resultRows`); one that cannot reports `unknown`.
+ */
+export type StatementEffect = "read" | "write" | "writeRows" | "writeTally" | "unknown";
 /** Result of an unsafe/raw execution: rows plus affected-row count. */
 export type QueryResult = {
     rows: Record<string, unknown>[];
@@ -212,15 +259,45 @@ export type DatabaseAdapter = {
      * provider name. Every adapter in this repository declares it.
      */
     readonly budgets?: AdapterBudgetSupport;
+    /**
+     * Whether a round trip to this adapter's engine crosses a network
+     * (`"network"`: a database server, even on a local socket) or stays inside
+     * this process (`"in-process"`: an embedded engine such as PGlite or SQLite).
+     *
+     * The runtime folds some multi-statement calls into ONE larger statement to
+     * save round trips (the nested-write fold and the upsert-fallback fold). On an
+     * in-process engine a round trip costs nothing, so only the larger
+     * statement's cost would remain: there the runtime keeps the multi-statement
+     * path, with the same results, errors and counts.
+     *
+     * OPTIONAL, so the frozen contract stays additive — exactly like
+     * {@link DatabaseAdapter.budgets}. An adapter that declares nothing is treated
+     * as `"network"`. Callers branch on this declaration, never on a provider
+     * name. Transactional adapters must carry the same declaration.
+     */
+    readonly roundTrips?: "network" | "in-process";
+    /**
+     * Whether a failed top-level {@link DatabaseAdapter.transaction} records a
+     * `TransactionOutcomeReport` on the value it throws (EPIC T) — read it with
+     * `transactionOutcomeOf({ error })`. The thrown value itself is unchanged.
+     *
+     * OPTIONAL, so the frozen contract stays additive — exactly like
+     * {@link DatabaseAdapter.roundTrips}. Undeclared = no reports. Callers branch
+     * on this declaration, never on a provider name. It describes the TOP-LEVEL
+     * call only: a transactional handle's nested `transaction()` (a savepoint)
+     * records nothing, so transactional handles do not declare it.
+     */
+    readonly transactionOutcome?: TransactionOutcomeSupport;
     /**
      * Run `fn` inside a transaction; the callback receives a transactional
      * adapter with this same interface. Nested calls create savepoints. Throwing
      * rolls back (the savepoint or the whole transaction) and rethrows.
      *
      * `options` is honored on TOP-LEVEL calls only. A NESTED call refuses any
-     * `isolationLevel` or `timeout` with `VIBE_VALIDATION` (`meta.nested:
-     * true`), identically on every adapter: a savepoint cannot change the
-     * isolation level of the transaction it joins, and a nested timeout is not
+     * `isolationLevel`, `timeout`, `deadline` or `accessMode` with
+     * `VIBE_VALIDATION` (`meta.nested: true`), identically on every adapter: a
+     * savepoint cannot change the isolation level of the transaction it joins,
+     * and a nested timeout is not
      * enforceable. Silently dropping the option was the pre-#3 behaviour of the
      * pg/pglite/mysql/bun adapters and is forbidden by constitution rule 4.
      */
@@ -232,14 +309,29 @@ export type DatabaseAdapter = {
      * Optional for third-party adapters; migration use refuses when unavailable.
      */
     readonly withSession?: SessionRunner;
-    /** Eagerly open/verify connectivity (pool warm-up or first connection). */
+    /**
+     * Eagerly open/verify connectivity (pool warm-up or first connection).
+     * Refuses with `VIBE_ADAPTER_CLOSED` once {@link DatabaseAdapter.disconnect}
+     * was called. On a transaction handle it refuses with `VIBE_VALIDATION`
+     * (`meta: { method, inTransaction: true }`): the transaction owns the connection.
+     */
     connect(): Promise<void>;
     /**
-     * Gracefully close the connections open right now. NOT terminal: every
-     * adapter constructs its pool/connection lazily, so a query issued after
-     * `disconnect()` transparently opens a NEW connection and succeeds — the
-     * documented contract (symmetric with lazy construction, and with Prisma's
-     * `$disconnect()`-then-query semantics), not an accident.
+     * End this adapter for good (terminal since EPIC A2). The first call seals
+     * the adapter synchronously: every later root call (`execute`,
+     * `executeUnsafe`, `transaction`, `withSession`, `connect`, …) refuses with
+     * `VIBE_ADAPTER_CLOSED` (`meta: { driver, state: "closing" | "closed" }`)
+     * and opens no pool or connection. Work admitted before the call drains
+     * first — a whole transaction or session callback included, whose handle
+     * keeps working until it returns — then the adapter closes what it OWNS,
+     * once; an injected pool/instance/database is never ended. Every call
+     * returns the same completion (a cleanup failure included). Called from
+     * inside one of this adapter's own running transaction/session callbacks,
+     * it refuses with `VIBE_TRANSACTION` (`meta.reason:
+     * "disconnect-in-active-callback"`) instead of waiting for itself. There is
+     * no timeout: stop producers and await pending work before closing. To
+     * connect again, create a new adapter. On a transaction handle it refuses
+     * with `VIBE_VALIDATION`, like `connect()`.
      */
     disconnect(): Promise<void>;
     /**

package/dist/client.d.ts

@@ -254,6 +254,13 @@ export type DynamicClient = {
      */
     readonly $tryAdvisoryLock: (options: AdvisoryLockOptions) => Promise<boolean>;
     readonly $connect: () => Promise<void>;
+    /**
+     * Flush pending diagnostics, end the adapter for good, then flush telemetry.
+     * The adapter's `disconnect()` is terminal: work this client (or any client
+     * sharing the adapter) issues afterwards refuses with `VIBE_ADAPTER_CLOSED`,
+     * `$connect()` included. Stop producers and await pending ORM work first;
+     * to connect again, create a new adapter and client.
+     */
     readonly $disconnect: () => Promise<void>;
     /**
      * Field-masking views (v1 `defineView` parity, board #11) — a read-only

package/dist/codecs.d.ts

@@ -24,6 +24,35 @@ export declare function getCodec(params: {
     dialect: Dialect;
     type: FieldType;
 }): ScalarCodec;
+/**
+ * Field-aware routing: membership survives identity pruning despite String
+ * transport, and `Float @db.Real` takes the float32 codec (shortest decimal
+ * that round-trips through float32 — a binary-format driver widens `0.1` to
+ * `0.10000000149011612`), and `DateTime @db.Time`/`@db.Timetz` take the
+ * time-of-day codec (UTC time of day out, `1970-01-01` in).
+ */
+/**
+ * Does this field hold a time of day (`DateTime @db.Time(n)` / `@db.Timetz(n)`)?
+ * The same rule that routes it to the time-of-day codec; membership predicates
+ * carry it to the dialect (`inArray.timeOfDay`).
+ */
+export declare function isTimeOfDayField(params: {
+    field: FieldMeta;
+}): boolean;
+/**
+ * Is this column projected as `"col"::text AS "col"` (SELECT and RETURNING)?
+ * True for postgres `Float[]` and `Json[]` columns: bun:sql's text array parser
+ * refuses a float array holding a value postgres prints with an exponent
+ * (`1e-05`, `1e+15`) and a json/jsonb array holding an integer beyond int32 or
+ * a nested `[null]` — the whole statement fails, after a write has already
+ * happened on RETURNING. The array literal text is parsed by the list decoder
+ * below instead (`fieldDecoder`). Other list types parse fine on every driver
+ * and are left alone — the text path costs JS parsing.
+ */
+export declare function projectsListAsText(params: {
+    dialect: Dialect;
+    field: FieldMeta;
+}): boolean;
 /**
  * Encode one value for parameter binding. `null`/`undefined` pass through
  * untouched (SQL NULL). List fields encode element-wise; the adapter's
@@ -161,6 +190,12 @@ export type PositionalMaterializer = (row: unknown) => Record<string, unknown>;
 export declare function positionalMaterializer(params: {
     model: ModelMeta;
     columns: readonly ColRef[];
+    /**
+     * R-02: trailing slots after `columns`, kept RAW under these names — a
+     * nested lateral's JSON, decoded by the next level with its own model's
+     * codecs. Never a schema field (`__rel_<name>` is a reserved prefix).
+     */
+    passthrough?: readonly string[];
 }): PositionalMaterializer;
 /**
  * Normalize one aggregate value — the contract, tested live on PGlite:

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runtime tunables. Internal: not exported from the package entry.
+ */
+/** Tunables of the client runtime, grouped in one frozen object. */
+export declare const RUNTIME_CONFIG: {
+    /**
+     * The nested write as ONE statement (round-trip campaign EPIC F) covers at
+     * most this many children; a longer list keeps today's path (parent
+     * statement + child statement in a transaction). EPIC F decision 3: at 1000
+     * children the one statement measured ~1.5× slower than the plain child
+     * INSERT locally; at 100 or fewer it is within ~1 ms.
+     */
+    readonly nestedFoldMaxChildren: number;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/extensions.d.ts

@@ -32,6 +32,16 @@ export type ExtensionMountContext = {
         values: readonly unknown[];
         method?: string;
     }) => Promise<Record<string, unknown>[]>;
+    /**
+     * The mount model's full row projection (`"t"."id", "t"."scores"::text AS
+     * "scores"`), every column qualified by `qualify`. Select this instead of
+     * `"t".*`: rows then hold exactly the model's columns, read the way
+     * `findMany` reads them — bun:sql refuses some `Float[]`/`Json[]` values
+     * when the driver parses the list itself.
+     */
+    readonly projection: (params: {
+        qualify: string;
+    }) => string;
     /** Compile a user `where` tree for AND-ing into extension SQL. */
     readonly compileWhere: (params: {
         where: Record<string, unknown>;

package/dist/find-page.d.ts

@@ -1,5 +1,5 @@
 import type { SqlDialect } from "@vibeorm/sql";
-import type { KeysetOrderPlan } from "./keyset.ts";
+import type { KeysetOrderPlan, KeysetQueryBinding } from "./keyset.ts";
 import type { ModelMeta, RuntimeMeta } from "./model-meta.ts";
 /** One bounded keyset page. A null continuation means the lookahead found no further row. */
 export type KeysetPage<T> = {
@@ -14,7 +14,12 @@ export declare function validatePageArgs(params: {
     model: string;
     args: unknown;
 }): PageArgs;
-/** Compile the first page's order too; findMany alone only requires a total order with after. */
+/**
+ * Compile the first page's order too; findMany alone only requires a total
+ * order with after. The binding is the query the page's tokens belong to: the
+ * `where` this engine compiles (any `$scoped` / `$withPolicy` predicate
+ * included) plus the caller's `keyset.scope`.
+ */
 export declare function preparePage(params: {
     meta: RuntimeMeta;
     model: ModelMeta;
@@ -22,11 +27,13 @@ export declare function preparePage(params: {
     args: PageArgs;
 }): {
     readonly plan: KeysetOrderPlan;
+    readonly binding: KeysetQueryBinding;
     readonly args: Record<string, unknown>;
 };
 /** Mint from the last delivered row before its hidden fields are projected away. */
 export declare function pageContinuation(params: {
     plan: KeysetOrderPlan;
+    binding: KeysetQueryBinding;
     rows: readonly Record<string, unknown>[];
     take: number;
     after: unknown;

package/dist/index.d.ts

@@ -15,13 +15,17 @@ export { compileAdvisoryLock } from "./advisory-lock.ts";
 export { advisoryKeyOf } from "./advisory-key.ts";
 export { transactionRowChanges } from "./transaction-row-changes.ts";
 export type { AdvisoryLockMethod, AdvisoryLockOptions } from "./advisory-lock.ts";
-export type { DatabaseAdapter, IsolationLevel, QueryResult, RowChangeCount, StatementEffect, SessionRunner, SqlExecutor, TransactionOptions, } from "./adapter.ts";
+export type { DatabaseAdapter, IsolationLevel, QueryResult, RowChangeCount, StatementEffect, SessionRunner, SqlExecutor, TransactionAccessMode, TransactionOptions, } from "./adapter.ts";
 export type { AdapterBudgetSupport, StatementTimeoutSupport, TransactionDeadline, TransactionDeadlineEnforcement, TransactionDeadlineSupport, } from "./adapter.ts";
+export { transactionOutcomeOf } from "./adapter-kit/transaction-outcome.ts";
+export type { ConnectionOutcome, RollbackOutcome, FailedCommitOutcome, TransactionOutcomeReport, } from "./adapter-kit/transaction-outcome.ts";
+export type { TransactionOutcome } from "./adapter-kit/transaction-budget.ts";
+export type { TransactionOutcomeSupport } from "./adapter.ts";
 export { buildRuntimeMeta, generateCuid, generateDefaultValue, generateNanoid, generateUlid, generateUuid, getFieldMeta, getModelMeta, toClientName, } from "./model-meta.ts";
 export type { ComputedFieldMeta, DefaultOrigin, ExtensionOperatorFn, FieldMeta, ModelMeta, RuntimeMeta, } from "./model-meta.ts";
 export { DIALECT_CODECS, MYSQL_CODECS, POSTGRES_CODECS, SQLITE_CODECS, decodeAggregateValue, decodeIsNoop, decodeRow, decodeRows, decodeValue, encodeValue, getCodec, } from "./codecs.ts";
 export type { CodecTable, ScalarCodec, WireFidelity } from "./codecs.ts";
-export { COUNT_ALIAS, buildQuery, compileOrderBy, compileSelect, compileWhere, lateralColumnAlias, resolveResultShape, } from "./query-builder.ts";
+export { COUNT_ALIAS, buildQuery, compileOrderBy, compileProjection, compileSelect, compileWhere, lateralColumnAlias, resolveResultShape, } from "./query-builder.ts";
 export type { AggregateKey, AggregateSelection, AggregateSpec, BuilderClientOptions, QueryMethod, QueryPlan, RelationStrategy, } from "./query-builder.ts";
 export { DIAGNOSTIC_THRESHOLDS, PLAN_DEFAULTS, STATEMENT_DIAGNOSTICS_DEFAULTS, analyzeOperationTelemetry, createStatementDiagnostics, explainOnSession, explainOperation, explainSql, formatStatementDiagnostic, isExecutableRead, parameterTypeTag, parseDiagnosticsEnv, parsePostgresPlan, previewOperation, readWorkloadStatistics, recommendFromPlan, resolveStatementDiagnostics, summarizePlan, } from "./diagnostics/index.ts";
 export type { DiagnosticFinding, DiagnosticFindingCode, ExplainMode, ExplainSkipReason, ObservedStatement, ResolvedStatementDiagnostics, StatementDiagnostic, StatementDiagnosticPlan, StatementDiagnosticsHook, StatementDiagnosticsOptions, StatementExplainMode, IndexCandidate, IndexFacts, OperationPreview, ParsedPlan, PlanContext, PlanNode, PreviewLimitation, PreviewLimitationCode, PreviewStatement, QueryPlanReport, SlowOperation, SuspectedPattern, TableFacts, TelemetryDiagnosticReport, WorkloadAvailability, WorkloadReport, WorkloadStatement, } from "./diagnostics/index.ts";
@@ -53,8 +57,8 @@ export type { BatchResult, ClientOptions, ClientRow, DynamicClient, ModelDelegat
 export { CLIENT_MEMBER_ACCESS, DELEGATE_METHOD_ACCESS, READ_DELEGATE_METHODS, WRITE_DELEGATE_METHODS, attachReadOnly, clientMemberAccess, createDelegateMethodClassifier, delegateMethodAccess, inheritReadOnly, readOnlyRefusal, } from "./read-only.ts";
 export type { ClientMemberAccess, DelegateMethodAccess, DelegateMethodClassifier, LazyOperationBridge, } from "./read-only.ts";
 export type { KeysetPage } from "./find-page.ts";
-export { KEYSET_MAX_PAGE_SIZE, KEYSET_TOKEN_PREFIX, KEYSET_TOKEN_VERSION, compileKeysetOrderPlan, decodeKeysetToken, encodeKeysetToken, keysetRowIsAfter, keysetRowValues, } from "./keyset.ts";
-export type { KeysetDirection, KeysetNulls, KeysetOrderInput, KeysetOrderKey, KeysetOrderPlan, KeysetTimestampPrecision, KeysetValueTag, } from "./keyset.ts";
+export { KEYSET_MAX_PAGE_SIZE, KEYSET_TOKEN_PREFIX, KEYSET_TOKEN_VERSION, compileKeysetOrderPlan, decodeKeysetToken, encodeKeysetToken, keysetQueryBinding, keysetRowIsAfter, keysetRowValues, } from "./keyset.ts";
+export type { KeysetDirection, KeysetNulls, KeysetOrderInput, KeysetOrderKey, KeysetOrderPlan, KeysetQueryBinding, KeysetTimestampPrecision, KeysetValueTag, } from "./keyset.ts";
 export { iterateKeyset } from "./keyset-iterator.ts";
 export type { KeysetIterateOptions, KeysetIterator, KeysetPageSource } from "./keyset-iterator.ts";
 export { compileKeysetOrderInputs } from "./query-builder.ts";