turbine-orm 0.79.0 → 0.79.1-next.e9dcb00

package/dist/cjs/client.js

@@ -28,7 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurbineClient = exports.TransactionClient = exports.READ_OPERATIONS = void 0;
 exports.withRetry = withRetry;
-const pg_1 = __importDefault(require("pg"));
+const _pg_1 = __importDefault(require("pg"));
 const connection_url_js_1 = require("./connection-url.js");
 const dialect_js_1 = require("./dialect.js");
 const errors_js_1 = require("./errors.js");
@@ -828,7 +828,7 @@ class TurbineClient {
         const ownsAnyPool = !config.pool;
         if (ownsAnyPool && !TurbineClient.int8ParserRegistered) {
             (0, utils_js_1.warnParserOverwrite)(20, 'int8');
-            pg_1.default.types.setTypeParser(20, (0, utils_js_1.markTurbineParser)((val) => {
+            _pg_1.default.types.setTypeParser(20, (0, utils_js_1.markTurbineParser)((val) => {
                 const n = Number(val);
                 return Number.isSafeInteger(n) ? n : val;
             }));
@@ -978,7 +978,7 @@ class TurbineClient {
             // Held as a `pg.Pool` for the length of this block: `PgCompatPool.on` is
             // optional (HTTP drivers have no pool events), and here we know we own a
             // real pg pool that has one. Same shape as the replica loop below.
-            const ownPool = new pg_1.default.Pool(TurbineClient.withPlanCacheMode(poolConfig, this.planCacheMode));
+            const ownPool = new _pg_1.default.Pool(TurbineClient.withPlanCacheMode(poolConfig, this.planCacheMode));
             ownPool.on('error', (err) => {
                 console.error('[turbine] Unexpected pool error:', err.message);
             });
@@ -995,7 +995,7 @@ class TurbineClient {
         this.ownedReplicaPools = [];
         for (const replica of config.replicas ?? []) {
             if (typeof replica === 'string') {
-                const replicaPool = new pg_1.default.Pool(TurbineClient.withPlanCacheMode({
+                const replicaPool = new _pg_1.default.Pool(TurbineClient.withPlanCacheMode({
                     connectionString: replica,
                     max: config.poolSize ?? config.max ?? 10,
                     idleTimeoutMillis: config.idleTimeoutMs ?? config.idleTimeoutMillis ?? 30_000,

package/dist/cjs/introspect.js

@@ -35,7 +35,7 @@ exports.buildRelationsFromForeignKeys = buildRelationsFromForeignKeys;
 exports.addAutoManyToManyRelations = addAutoManyToManyRelations;
 exports.deriveCatalogRelations = deriveCatalogRelations;
 exports.deriveEngineRelations = deriveEngineRelations;
-const pg_1 = __importDefault(require("pg"));
+const _pg_1 = __importDefault(require("pg"));
 const dialect_js_1 = require("./dialect.js");
 const errors_js_1 = require("./errors.js");
 const schema_js_1 = require("./schema.js");
@@ -541,7 +541,7 @@ function assertDistinctColumnFields(tableName, columns) {
 async function introspectPostgresCatalog(options) {
     const schema = options.schema ?? 'public';
     const dialect = dialect_js_1.postgresDialect;
-    const pool = new pg_1.default.Pool({
+    const pool = new _pg_1.default.Pool({
         connectionString: options.connectionString,
         max: 1,
         connectionTimeoutMillis: 10_000,

package/dist/cjs/observe.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObserveEngine = exports.HttpJsonSink = exports.PgMetricsSink = void 0;
 exports.floorToMinute = floorToMinute;
 exports.percentile = percentile;
-const pg_1 = __importDefault(require("pg"));
+const _pg_1 = __importDefault(require("pg"));
 const errors_js_1 = require("./errors.js");
 /**
  * Buffer key: minute bucket + model + action. Joined on a NUL, which cannot
@@ -82,7 +82,7 @@ class PgMetricsSink {
     pool;
     retentionDays;
     constructor(options) {
-        this.pool = new pg_1.default.Pool({ connectionString: options.connectionString, max: 1 });
+        this.pool = new _pg_1.default.Pool({ connectionString: options.connectionString, max: 1 });
         this.retentionDays = options.retentionDays ?? 30;
     }
     async init() {

package/dist/cjs/pg-edge.d.ts

@@ -0,0 +1,42 @@
+/**
+ * turbine-orm, the stand-in for `pg` on runtimes that cannot run it.
+ *
+ * The modules the serverless entry shares with the main entry import the
+ * driver as `#pg`, a package.json `imports` alias. It resolves to the real `pg`
+ * everywhere except under the `edge-light` and `browser` conditions (Vercel
+ * Edge, Next.js edge routes, browser bundles), where it resolves to this file.
+ * Those runtimes have no TCP sockets and no `fs`, `net` or `tls`, so bundling
+ * `pg` there fails the build outright, although `turbineHttp()` never opens a
+ * pg connection. `workerd` keeps the real driver: `pg` supports Cloudflare
+ * Workers, and a Hyperdrive user may let Turbine open the pool.
+ *
+ * What the shared code touches on a caller-supplied pool:
+ *   - `types.getTypeParser`, when a relation's JSON column is decoded with the
+ *     driver's text parser. The identity parser here leaves the JSON wire text
+ *     as it arrived (a `date` inside a relation stays a string), which is also
+ *     what an HTTP driver that ships its own type parsers would disagree with
+ *     least.
+ *   - nothing else: parser registration, `new pg.Pool` and the pipeline wire
+ *     protocol only run when Turbine owns a TCP pool, and on this runtime that
+ *     is the error below instead of an unresolvable import.
+ */
+declare function unavailable(): never;
+declare class Unavailable {
+    constructor();
+}
+declare const pg: {
+    Pool: typeof Unavailable;
+    Client: typeof Unavailable;
+    Result: typeof Unavailable;
+    utils: {
+        prepareValue: typeof unavailable;
+    };
+    types: {
+        getTypeParser: () => (value: string) => string;
+        setTypeParser: () => void;
+        arrayParser: {
+            create: typeof unavailable;
+        };
+    };
+};
+export default pg;

package/dist/cjs/pg-edge.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * turbine-orm, the stand-in for `pg` on runtimes that cannot run it.
+ *
+ * The modules the serverless entry shares with the main entry import the
+ * driver as `#pg`, a package.json `imports` alias. It resolves to the real `pg`
+ * everywhere except under the `edge-light` and `browser` conditions (Vercel
+ * Edge, Next.js edge routes, browser bundles), where it resolves to this file.
+ * Those runtimes have no TCP sockets and no `fs`, `net` or `tls`, so bundling
+ * `pg` there fails the build outright, although `turbineHttp()` never opens a
+ * pg connection. `workerd` keeps the real driver: `pg` supports Cloudflare
+ * Workers, and a Hyperdrive user may let Turbine open the pool.
+ *
+ * What the shared code touches on a caller-supplied pool:
+ *   - `types.getTypeParser`, when a relation's JSON column is decoded with the
+ *     driver's text parser. The identity parser here leaves the JSON wire text
+ *     as it arrived (a `date` inside a relation stays a string), which is also
+ *     what an HTTP driver that ships its own type parsers would disagree with
+ *     least.
+ *   - nothing else: parser registration, `new pg.Pool` and the pipeline wire
+ *     protocol only run when Turbine owns a TCP pool, and on this runtime that
+ *     is the error below instead of an unresolvable import.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_js_1 = require("./errors.js");
+function unavailable() {
+    throw new errors_js_1.ConnectionError('turbine-orm cannot open its own Postgres connection in this runtime: it has no TCP driver. ' +
+        'Pass a pg-compatible pool instead of a connection string, e.g. turbineHttp(pool, schema) from turbine-orm/serverless.');
+}
+class Unavailable {
+    constructor() {
+        unavailable();
+    }
+}
+const identity = (value) => value;
+const pg = {
+    Pool: Unavailable,
+    Client: Unavailable,
+    Result: Unavailable,
+    utils: { prepareValue: unavailable },
+    types: {
+        getTypeParser: () => identity,
+        setTypeParser: () => { },
+        arrayParser: { create: unavailable },
+    },
+};
+exports.default = pg;

package/dist/cjs/pipeline-submittable.js

@@ -24,9 +24,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipelineClientNeedsDiscard = pipelineClientNeedsDiscard;
 exports.runPipelined = runPipelined;
 exports.supportsExtendedPipeline = supportsExtendedPipeline;
-const result_1 = __importDefault(require("pg/lib/result"));
-const utils_1 = require("pg/lib/utils");
+const _pg_1 = __importDefault(require("pg"));
 const errors_js_1 = require("./errors.js");
+// Read off pg's own module object (`pg.Result` IS `pg/lib/result`, `pg.utils`
+// IS `pg/lib/utils`) rather than imported by subpath, so the whole driver comes
+// through the one `#pg` alias that edge bundles swap out (see src/pg-edge.ts).
+const Result = _pg_1.default.Result;
+const { prepareValue } = _pg_1.default.utils;
 /**
  * Marks a client this module could not hand back in a reusable state, so the
  * caller releases it WITH an error and the pool drops it instead of lending it
@@ -130,7 +134,7 @@ async function runPipelined(client, queries, options = {}) {
         // Results array: one Result per query (not counting BEGIN/COMMIT)
         const results = [];
         for (let i = 0; i < queries.length; i++) {
-            results.push(new result_1.default(undefined, client._types));
+            results.push(new Result(undefined, client._types));
         }
         // commandComplete counter, tracks position across all commands
         let commandIndex = 0;
@@ -230,7 +234,7 @@ async function runPipelined(client, queries, options = {}) {
             rollbackSent = true;
             try {
                 connection.parse({ text: 'ROLLBACK', name: '' });
-                connection.bind({ portal: '', statement: '', values: [], valueMapper: utils_1.prepareValue });
+                connection.bind({ portal: '', statement: '', values: [], valueMapper: prepareValue });
                 connection.execute({ portal: '', rows: 0 });
                 connection.sync();
                 return false;
@@ -428,7 +432,7 @@ async function runPipelined(client, queries, options = {}) {
                 // One sync = one ReadyForQuery
                 // BEGIN
                 connection.parse({ text: 'BEGIN', name: '' });
-                connection.bind({ portal: '', statement: '', values: [], valueMapper: utils_1.prepareValue });
+                connection.bind({ portal: '', statement: '', values: [], valueMapper: prepareValue });
                 connection.execute({ portal: '', rows: 0 });
                 // Each query
                 for (const q of queries) {
@@ -437,14 +441,14 @@ async function runPipelined(client, queries, options = {}) {
                         portal: '',
                         statement: '',
                         values: q.params,
-                        valueMapper: utils_1.prepareValue,
+                        valueMapper: prepareValue,
                     });
                     connection.describe({ type: 'P', name: '' });
                     connection.execute({ portal: '', rows: 0 });
                 }
                 // COMMIT
                 connection.parse({ text: 'COMMIT', name: '' });
-                connection.bind({ portal: '', statement: '', values: [], valueMapper: utils_1.prepareValue });
+                connection.bind({ portal: '', statement: '', values: [], valueMapper: prepareValue });
                 connection.execute({ portal: '', rows: 0 });
                 // Single Sync
                 connection.sync();
@@ -460,7 +464,7 @@ async function runPipelined(client, queries, options = {}) {
                         portal: '',
                         statement: '',
                         values: q.params,
-                        valueMapper: utils_1.prepareValue,
+                        valueMapper: prepareValue,
                     });
                     connection.describe({ type: 'P', name: '' });
                     connection.execute({ portal: '', rows: 0 });

package/dist/cjs/query/utils.js

@@ -51,7 +51,7 @@ exports.warnRedundantSortTerm = warnRedundantSortTerm;
 exports.selectNamesNothingMessage = selectNamesNothingMessage;
 exports.selectOmitExclusiveMessage = selectOmitExclusiveMessage;
 exports.normalizePagination = normalizePagination;
-const pg_1 = __importDefault(require("pg"));
+const _pg_1 = __importDefault(require("pg"));
 const errors_js_1 = require("../errors.js");
 const schema_js_1 = require("../schema.js");
 const warn_registry_js_1 = require("./warn-registry.js");
@@ -999,7 +999,7 @@ function parseUtcTimestampText(text) {
  * the hard way.
  */
 function createPgArrayParser(element) {
-    const arrayParser = pg_1.default.types.arrayParser;
+    const arrayParser = _pg_1.default.types.arrayParser;
     return (text) => text
         ? arrayParser.create(text, (entry) => (entry === null || entry === undefined ? null : element(entry))).parse()
         : null;
@@ -1129,7 +1129,7 @@ function isDefaultTextParser(oid, parser) {
  * being replaced.
  */
 function warnParserOverwrite(oid, typeName) {
-    const getParser = pg_1.default.types.getTypeParser;
+    const getParser = _pg_1.default.types.getTypeParser;
     const current = getParser(oid, 'text');
     // Turbine's own earlier registration is not a third party's expectation.
     if (current[TURBINE_PARSER])
@@ -1193,8 +1193,8 @@ function registerUtcTemporalParsers() {
     // pg-types declares get/setTypeParser over its own OID enum, which lists the
     // scalar types only. The array OIDs are just as real, so both calls are
     // retyped over a plain number rather than the incomplete enum.
-    const getParser = pg_1.default.types.getTypeParser;
-    const setParser = pg_1.default.types.setTypeParser;
+    const getParser = _pg_1.default.types.getTypeParser;
+    const setParser = _pg_1.default.types.setTypeParser;
     warnParserOverwrite(1114, 'timestamp');
     warnParserOverwrite(1082, 'date');
     warnParserOverwrite(1115, 'timestamp[]');
@@ -1251,8 +1251,8 @@ function registerUtcTemporalParsers() {
  * what makes it so, and is not an optimisation of it.
  */
 function registerFastTemporalParserIfDefault(oid, build) {
-    const getParser = pg_1.default.types.getTypeParser;
-    const setParser = pg_1.default.types.setTypeParser;
+    const getParser = _pg_1.default.types.getTypeParser;
+    const setParser = _pg_1.default.types.setTypeParser;
     const current = getParser(oid, 'text');
     const isTurbines = current[TURBINE_PARSER] === true;
     if (!isTurbines && !isDefaultTextParser(oid, current))
@@ -1347,7 +1347,7 @@ function jsonWireCoercionOid(pgType) {
 function coerceJsonWireValue(oid, value) {
     if (typeof value !== 'string')
         return value;
-    return pg_1.default.types.getTypeParser(oid, 'text')(value);
+    return _pg_1.default.types.getTypeParser(oid, 'text')(value);
 }
 // ---------------------------------------------------------------------------
 // Unknown-field diagnostics

package/dist/cjs/query-events.d.ts

@@ -72,6 +72,13 @@ export declare function deferredIdentity(tag: string): {
  * {@link RAW_QUERY_MODEL} and the action names the entry point (`'raw'`,
  * `'sql'`, `'rawQuery'`, `'$queryRaw'` ...). `wrap` turns a driver error into
  * what the caller sees, and the event carries that same error.
+ *
+ * The failure is reported from inside the `catch`, never handed to a `finally`
+ * through a local. SWC's minifier (the one Next.js runs over server bundles)
+ * treats `error = wrap(err); throw error;` as a single-use temporary and
+ * rewrites it to `throw wrap(err)`, dropping the assignment the `finally` then
+ * reads. Every failed statement in a minified bundle was reported as a
+ * success. `minified-events.test.ts` runs this module through that minifier.
  */
 export declare function runReportedStatement<R extends {
     rowCount?: number | null;

package/dist/cjs/query-events.js

@@ -103,31 +103,39 @@ function deferredIdentity(tag) {
  * {@link RAW_QUERY_MODEL} and the action names the entry point (`'raw'`,
  * `'sql'`, `'rawQuery'`, `'$queryRaw'` ...). `wrap` turns a driver error into
  * what the caller sees, and the event carries that same error.
+ *
+ * The failure is reported from inside the `catch`, never handed to a `finally`
+ * through a local. SWC's minifier (the one Next.js runs over server bundles)
+ * treats `error = wrap(err); throw error;` as a single-use temporary and
+ * rewrites it to `throw wrap(err)`, dropping the assignment the `finally` then
+ * reads. Every failed statement in a minified bundle was reported as a
+ * success. `minified-events.test.ts` runs this module through that minifier.
  */
 async function runReportedStatement(sink, identity, sql, params, run, wrap) {
     const start = performance.now();
+    const report = (rows, error) => {
+        if (!sink)
+            return;
+        emitStatementEvent(sink, {
+            ...identity,
+            sql,
+            params,
+            duration: performance.now() - start,
+            rows,
+            ...(error === undefined ? {} : { error }),
+        });
+    };
     let result;
-    let error;
     try {
         result = await run();
-        return result;
     }
     catch (err) {
-        error = wrap(err);
+        const error = wrap(err);
+        report(0, error instanceof Error ? error : new Error(String(error)));
         throw error;
     }
-    finally {
-        if (sink) {
-            emitStatementEvent(sink, {
-                ...identity,
-                sql,
-                params,
-                duration: performance.now() - start,
-                rows: resultRowCount(result),
-                ...(error === undefined ? {} : { error: error instanceof Error ? error : new Error(String(error)) }),
-            });
-        }
-    }
+    report(resultRowCount(result));
+    return result;
 }
 /** The identity of a raw statement run through `action`. */
 const rawIdentity = (action) => ({

package/dist/client.js

@@ -21,7 +21,7 @@
  * const users = db.table<User>('users');
  * ```
  */
-import pg from 'pg';
+import pg from '#pg';
 import { mergeConnectionStringOptions } from './connection-url.js';
 import { postgresDialect } from './dialect.js';
 import { ConnectionError, errorMessageModesDiverged, PipelineError, registerClientErrorMessageMode, runWithErrorMessageMode, setErrorMessageMode, TimeoutError, UnsupportedFeatureError, ValidationError, wrapPgError, } from './errors.js';

package/dist/introspect.js

@@ -7,7 +7,7 @@
  *
  * This is the foundation of `npx turbine generate`.
  */
-import pg from 'pg';
+import pg from '#pg';
 import { postgresDialect } from './dialect.js';
 import { ValidationError } from './errors.js';
 import { isDateType, pgTypeToTs, singularize, snakeToCamel, } from './schema.js';

package/dist/observe.js

@@ -12,7 +12,7 @@
  * model/action identity, the counts, and the latency percentiles. It never
  * carries SQL text or bound parameter values.
  */
-import pg from 'pg';
+import pg from '#pg';
 import { ValidationError } from './errors.js';
 /**
  * Buffer key: minute bucket + model + action. Joined on a NUL, which cannot

package/dist/pg-edge.d.ts

@@ -0,0 +1,42 @@
+/**
+ * turbine-orm, the stand-in for `pg` on runtimes that cannot run it.
+ *
+ * The modules the serverless entry shares with the main entry import the
+ * driver as `#pg`, a package.json `imports` alias. It resolves to the real `pg`
+ * everywhere except under the `edge-light` and `browser` conditions (Vercel
+ * Edge, Next.js edge routes, browser bundles), where it resolves to this file.
+ * Those runtimes have no TCP sockets and no `fs`, `net` or `tls`, so bundling
+ * `pg` there fails the build outright, although `turbineHttp()` never opens a
+ * pg connection. `workerd` keeps the real driver: `pg` supports Cloudflare
+ * Workers, and a Hyperdrive user may let Turbine open the pool.
+ *
+ * What the shared code touches on a caller-supplied pool:
+ *   - `types.getTypeParser`, when a relation's JSON column is decoded with the
+ *     driver's text parser. The identity parser here leaves the JSON wire text
+ *     as it arrived (a `date` inside a relation stays a string), which is also
+ *     what an HTTP driver that ships its own type parsers would disagree with
+ *     least.
+ *   - nothing else: parser registration, `new pg.Pool` and the pipeline wire
+ *     protocol only run when Turbine owns a TCP pool, and on this runtime that
+ *     is the error below instead of an unresolvable import.
+ */
+declare function unavailable(): never;
+declare class Unavailable {
+    constructor();
+}
+declare const pg: {
+    Pool: typeof Unavailable;
+    Client: typeof Unavailable;
+    Result: typeof Unavailable;
+    utils: {
+        prepareValue: typeof unavailable;
+    };
+    types: {
+        getTypeParser: () => (value: string) => string;
+        setTypeParser: () => void;
+        arrayParser: {
+            create: typeof unavailable;
+        };
+    };
+};
+export default pg;

package/dist/pg-edge.js

@@ -0,0 +1,45 @@
+/**
+ * turbine-orm, the stand-in for `pg` on runtimes that cannot run it.
+ *
+ * The modules the serverless entry shares with the main entry import the
+ * driver as `#pg`, a package.json `imports` alias. It resolves to the real `pg`
+ * everywhere except under the `edge-light` and `browser` conditions (Vercel
+ * Edge, Next.js edge routes, browser bundles), where it resolves to this file.
+ * Those runtimes have no TCP sockets and no `fs`, `net` or `tls`, so bundling
+ * `pg` there fails the build outright, although `turbineHttp()` never opens a
+ * pg connection. `workerd` keeps the real driver: `pg` supports Cloudflare
+ * Workers, and a Hyperdrive user may let Turbine open the pool.
+ *
+ * What the shared code touches on a caller-supplied pool:
+ *   - `types.getTypeParser`, when a relation's JSON column is decoded with the
+ *     driver's text parser. The identity parser here leaves the JSON wire text
+ *     as it arrived (a `date` inside a relation stays a string), which is also
+ *     what an HTTP driver that ships its own type parsers would disagree with
+ *     least.
+ *   - nothing else: parser registration, `new pg.Pool` and the pipeline wire
+ *     protocol only run when Turbine owns a TCP pool, and on this runtime that
+ *     is the error below instead of an unresolvable import.
+ */
+import { ConnectionError } from './errors.js';
+function unavailable() {
+    throw new ConnectionError('turbine-orm cannot open its own Postgres connection in this runtime: it has no TCP driver. ' +
+        'Pass a pg-compatible pool instead of a connection string, e.g. turbineHttp(pool, schema) from turbine-orm/serverless.');
+}
+class Unavailable {
+    constructor() {
+        unavailable();
+    }
+}
+const identity = (value) => value;
+const pg = {
+    Pool: Unavailable,
+    Client: Unavailable,
+    Result: Unavailable,
+    utils: { prepareValue: unavailable },
+    types: {
+        getTypeParser: () => identity,
+        setTypeParser: () => { },
+        arrayParser: { create: unavailable },
+    },
+};
+export default pg;

package/dist/pipeline-submittable.js

@@ -16,9 +16,13 @@
  * This is the same pattern used by pg-cursor and pg-query-stream, but extended
  * to handle N queries in a single pipeline.
  */
-import Result from 'pg/lib/result';
-import { prepareValue } from 'pg/lib/utils';
+import pg from '#pg';
 import { PipelineError, TimeoutError, wrapPgError } from './errors.js';
+// Read off pg's own module object (`pg.Result` IS `pg/lib/result`, `pg.utils`
+// IS `pg/lib/utils`) rather than imported by subpath, so the whole driver comes
+// through the one `#pg` alias that edge bundles swap out (see src/pg-edge.ts).
+const Result = pg.Result;
+const { prepareValue } = pg.utils;
 /**
  * Marks a client this module could not hand back in a reusable state, so the
  * caller releases it WITH an error and the pool drops it instead of lending it

package/dist/query/utils.js

@@ -3,7 +3,7 @@
  *
  * Standalone utility functions and classes used by the query builder.
  */
-import pg from 'pg';
+import pg from '#pg';
 import { ValidationError } from '../errors.js';
 import { camelToSnake, localDateTimeKind, snakeToCamel, timeOfDayKind } from '../schema.js';
 import { shouldWarnOnce, WARN_NS } from './warn-registry.js';

package/dist/query-events.d.ts

@@ -72,6 +72,13 @@ export declare function deferredIdentity(tag: string): {
  * {@link RAW_QUERY_MODEL} and the action names the entry point (`'raw'`,
  * `'sql'`, `'rawQuery'`, `'$queryRaw'` ...). `wrap` turns a driver error into
  * what the caller sees, and the event carries that same error.
+ *
+ * The failure is reported from inside the `catch`, never handed to a `finally`
+ * through a local. SWC's minifier (the one Next.js runs over server bundles)
+ * treats `error = wrap(err); throw error;` as a single-use temporary and
+ * rewrites it to `throw wrap(err)`, dropping the assignment the `finally` then
+ * reads. Every failed statement in a minified bundle was reported as a
+ * success. `minified-events.test.ts` runs this module through that minifier.
  */
 export declare function runReportedStatement<R extends {
     rowCount?: number | null;

package/dist/query-events.js

@@ -94,31 +94,39 @@ export function deferredIdentity(tag) {
  * {@link RAW_QUERY_MODEL} and the action names the entry point (`'raw'`,
  * `'sql'`, `'rawQuery'`, `'$queryRaw'` ...). `wrap` turns a driver error into
  * what the caller sees, and the event carries that same error.
+ *
+ * The failure is reported from inside the `catch`, never handed to a `finally`
+ * through a local. SWC's minifier (the one Next.js runs over server bundles)
+ * treats `error = wrap(err); throw error;` as a single-use temporary and
+ * rewrites it to `throw wrap(err)`, dropping the assignment the `finally` then
+ * reads. Every failed statement in a minified bundle was reported as a
+ * success. `minified-events.test.ts` runs this module through that minifier.
  */
 export async function runReportedStatement(sink, identity, sql, params, run, wrap) {
     const start = performance.now();
+    const report = (rows, error) => {
+        if (!sink)
+            return;
+        emitStatementEvent(sink, {
+            ...identity,
+            sql,
+            params,
+            duration: performance.now() - start,
+            rows,
+            ...(error === undefined ? {} : { error }),
+        });
+    };
     let result;
-    let error;
     try {
         result = await run();
-        return result;
     }
     catch (err) {
-        error = wrap(err);
+        const error = wrap(err);
+        report(0, error instanceof Error ? error : new Error(String(error)));
         throw error;
     }
-    finally {
-        if (sink) {
-            emitStatementEvent(sink, {
-                ...identity,
-                sql,
-                params,
-                duration: performance.now() - start,
-                rows: resultRowCount(result),
-                ...(error === undefined ? {} : { error: error instanceof Error ? error : new Error(String(error)) }),
-            });
-        }
-    }
+    report(resultRowCount(result));
+    return result;
 }
 /** The identity of a raw statement run through `action`. */
 export const rawIdentity = (action) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.79.0",
+  "version": "0.79.1-next.e9dcb00",
   "description": "Postgres-native TypeScript ORM, runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "//exports": "Each subpath declares its types PER CONDITION. A single shared top-level \"types\" resolves to the ESM declarations for `require` too, which is TS1479 (\"is an ES module ... cannot be require()d\") for any CJS consumer on moduleResolution node16/nodenext. The require condition points at dist/cjs, which ships its own {\"type\":\"commonjs\"} package.json, so those declarations are CJS declarations. Gated in CI by publint + @arethetypeswrong/cli + a real .cts consumer typecheck (see the package-types job in ci.yml).",
@@ -96,6 +96,15 @@
       }
     }
   },
+  "//imports": "`#pg` is how the modules shared with the serverless entry reach node-postgres. It is `pg` itself everywhere except edge-light and browser, which get dist/pg-edge.js (see src/pg-edge.ts): those runtimes cannot bundle pg at all, and turbineHttp() never uses it. workerd is listed first so Cloudflare keeps the real driver (pg supports Workers). An imports target may be a bare package name, which is what keeps src/ runnable under tsx with no dist/ present. The CJS build (dist/cjs) is Node-only: scripts/finish-cjs-build.mjs rewrites its require(\"#pg\") to require(\"pg\"), because a require() resolves #imports against the NEAREST package.json (dist/cjs/package.json) and publint rejects a nested imports field. Edge bundlers resolve the import condition, i.e. the ESM files. `npm run check:edge` bundles the serverless entry for the edge conditions and fails on any pg or Node-builtin import.",
+  "imports": {
+    "#pg": {
+      "workerd": "pg",
+      "edge-light": "./dist/pg-edge.js",
+      "browser": "./dist/pg-edge.js",
+      "default": "pg"
+    }
+  },
   "main": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
@@ -115,7 +124,7 @@
   "//prepublishOnly": "The gate for a MANUAL LOCAL `npm publish`, which is the normal release flow here, so it is the ONLY gate on that path (release.yml runs on a pushed tag, and a local publish never triggers it). `check:package` joined it 2026-07-28: publint --strict + attw --pack, the two checks that catch a broken exports map or CJS declarations that resolve to ESM, which is a class of bug that shipped once already and is invisible to every other script here. `test:coverage:cli` joined at the same time (~3s) so a local publish cannot ship a Studio/migrate coverage regression. Still deliberately absent, because they need containers or minutes of packing: the non-Postgres engine suites and the tarball install smoke, which release.yml + ci.yml run. check:cycles joined 2026-08-02 (the query/->client.ts acyclicity rule as a build failure instead of CLAUDE.md prose). check:release-tests joined at the same time and runs LAST because it is the expensive one: outside CI it runs the full DB-backed `npm test` (refusing to publish when no DATABASE_URL is reachable, escape hatch TURBINE_PUBLISH_WITHOUT_DB=1), which closes the old gap where the release path never executed a query against a real Postgres; in CI it self-skips since release.yml/nightly.yml run that suite as dedicated jobs. Known double-coverage: `npm test` re-runs the unit-lane files serially, so a local publish executes them twice; accepted, the second pass is the one with a real database behind it.",
   "scripts": {
     "prebuild": "npm run gen:studio",
-    "build": "rm -rf dist && tsc && tsc --project tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "build": "rm -rf dist && tsc && tsc --project tsconfig.cjs.json && node scripts/finish-cjs-build.mjs",
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit --project tsconfig.test.json",
     "generate": "tsx src/cli/index.ts generate",
@@ -165,7 +174,9 @@
     "check:package": "publint --strict && attw --pack . --profile node16",
     "//check:package-types": "The @types/pg tripwire, and the permanent guard on the v0.28.1 regression: no reference to the pg module family may reach a published .d.ts, or a types-only package becomes a hard requirement for every consumer compiling under strict. It lived as an inline grep in ONE ci.yml job, which left the gate proving the change safe off the publish path entirely (a tag push and a local `npm publish` both reached npm without asking). The logic is scripts/check-no-pg-types.mjs now and this script is its single entry point, called by prepublishOnly and by the `consumer-types` job in BOTH ci.yml and release.yml. Reads dist/, so it must run after `npm run build`.",
     "check:package-types": "node scripts/check-no-pg-types.mjs",
-    "prepublishOnly": "npm run build && npm run typecheck && npm run lint && npm run test:unit && npm run test:coverage:cli && npm run check:error-codes && npm run check:error-prefix && npm run check:changelog && npm run check:cycles && npm run check:skip-gates && npm run check:private-terms && npm run check:package && npm run check:package-types && npm run size && npm run check:release-tests",
+    "//check:edge": "The edge-runtime gate for turbine-orm/serverless: bundles dist/serverless.js (the ESM build, which is what edge bundlers resolve) with esbuild under the edge-light/worker/browser conditions and fails on any pg-family import, any Node builtin but node:async_hooks, or any other package. Every other gate here runs on Node, which is how a static `import pg from 'pg'` in a shared module broke every edge build while CI stayed green. A CONTROL bundle under Node conditions must reach pg first, or the scan refuses to pass. Reads dist/, so it runs after `npm run build`: in prepublishOnly, and in the build job of ci.yml and the test job of release.yml.",
+    "check:edge": "node scripts/check-edge-bundle.mjs",
+    "prepublishOnly": "npm run build && npm run typecheck && npm run lint && npm run test:unit && npm run test:coverage:cli && npm run check:error-codes && npm run check:error-prefix && npm run check:changelog && npm run check:cycles && npm run check:skip-gates && npm run check:private-terms && npm run check:package && npm run check:package-types && npm run check:edge && npm run size && npm run check:release-tests",
     "prepack": "node scripts/strip-prepare.mjs",
     "postpack": "node scripts/restore-prepare.mjs",
     "size": "size-limit",
@@ -195,11 +206,13 @@
     "@biomejs/biome": "^2.4.10",
     "@size-limit/esbuild": "^12.1.0",
     "@size-limit/file": "^12.1.0",
+    "@swc/core": "1.16.2",
     "@types/node": "^26.1.0",
     "@types/pg": "^8.11.11",
     "@zvndev/powdb-client": "^0.20.0",
     "@zvndev/powdb-embedded": "^0.20.0",
     "c8": "^11.0.0",
+    "esbuild": "^0.28.2",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.8",
     "mssql": "^12.7.0",