turbine-orm 0.50.0 → 0.51.0

package/dist/cjs/schema-sql.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Schema SQL Generator
+ * turbine-orm, Schema SQL Generator
  *
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
@@ -15,7 +15,7 @@ export interface SchemaSqlOptions {
     /**
      * How to handle the pgvector extension when the schema contains a `vector`
      * column. `'auto'` (default) prepends `CREATE EXTENSION IF NOT EXISTS vector;`
-     * — appropriate for `push`. `'manual'` emits a leading comment only, so the
+     * - appropriate for `push`. `'manual'` emits a leading comment only, so the
      * generated `.sql` migration doesn't silently require superuser privileges.
      */
     extensions?: 'auto' | 'manual';
@@ -72,11 +72,11 @@ export interface AlterDef {
     columns: AlterColumnDef[];
 }
 export interface DiffResult {
-    /** Tables that exist in schema but not in DB — need CREATE TABLE */
+    /** Tables that exist in schema but not in DB, need CREATE TABLE */
     create: TableDef[];
-    /** Tables that exist in both but differ — need ALTER TABLE */
+    /** Tables that exist in both but differ, need ALTER TABLE */
     alter: AlterDef[];
-    /** Table names that exist in DB but not in schema — would need DROP TABLE */
+    /** Table names that exist in DB but not in schema, would need DROP TABLE */
     drop: string[];
     /** SQL statements to execute the diff (UP direction) */
     statements: string[];
@@ -85,7 +85,7 @@ export interface DiffResult {
     /**
      * Human-readable warnings for changes the diff detected but refuses to apply
      * automatically because they are destructive or otherwise unsafe (enum value
-     * removal/reorder, etc.). Never executed — surfaced for the operator.
+     * removal/reorder, etc.). Never executed, surfaced for the operator.
      */
     warnings?: string[];
 }
@@ -106,7 +106,7 @@ export interface DbForeignKey {
 export declare function buildAddForeignKeyStatement(table: string, constraintName: string, column: string, targetTable: string, targetColumn: string, onDelete: ReferentialAction, onUpdate: ReferentialAction, dialect?: Dialect): string;
 /**
  * Decide whether a FK's referential actions changed. When they differ, returns
- * the DROP + ADD CONSTRAINT statements (and their reverse) — Postgres has no
+ * the DROP + ADD CONSTRAINT statements (and their reverse), Postgres has no
  * `ALTER CONSTRAINT` for referential actions, so drop-and-recreate is the only
  * path. Returns null when the actions already match.
  */
@@ -117,7 +117,7 @@ export declare function diffReferentialAction(table: string, db: DbForeignKey, s
 /**
  * Compute append-only enum value changes. Returns `ALTER TYPE ... ADD VALUE`
  * statements for labels present in the schema but not the DB (in order), plus a
- * destructive warning for any DB label the schema dropped or any reorder —
+ * destructive warning for any DB label the schema dropped or any reorder -
  * Postgres cannot remove or reorder enum values without recreating the type.
  */
 export declare function diffEnumValues(enumName: string, schemaLabels: readonly string[], dbLabels: readonly string[], dialect?: Dialect): {
@@ -147,7 +147,7 @@ export interface CheckSpec {
  * Diff a table's CHECK constraints (matched by name). Adds constraints missing
  * from the DB, drops DB constraints absent from the schema, and drop+adds when a
  * same-named constraint's expression changed. Expression comparison is a naive
- * whitespace-insensitive match — semantically-equal-but-different-spelled
+ * whitespace-insensitive match, semantically-equal-but-different-spelled
  * expressions may re-emit (documented; harmless drop+add).
  */
 export declare function diffCheckConstraints(table: string, schemaChecks: readonly CheckSpec[], dbChecks: readonly CheckSpec[], dialect?: Dialect): {

package/dist/cjs/schema-sql.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * turbine-orm — Schema SQL Generator
+ * turbine-orm, Schema SQL Generator
  *
  * Converts a SchemaDef (from defineSchema) into executable DDL statements.
  * Also provides diff and push commands for syncing schema to a live database.
@@ -51,7 +51,7 @@ function quoteEnumLabel(label) {
 /**
  * Whether a resolved column type is an auto-increment pseudo-type (SERIAL /
  * BIGSERIAL). These carry an implicit sequence default and NOT NULL, and their
- * underlying integer width (int4 vs int8) is never auto-migrated by diff — a
+ * underlying integer width (int4 vs int8) is never auto-migrated by diff, a
  * width change on a live PK is destructive and must be done by hand.
  */
 function isSerialType(type) {
@@ -74,7 +74,7 @@ function generateCreateEnumType(enumName, labels, dialect) {
 }
 /**
  * Resolve the DDL type token for a column: an enum type name, a `vector(n)`
- * literal, or the dialect's scalar type — with a trailing `[]` for arrays.
+ * literal, or the dialect's scalar type, with a trailing `[]` for arrays.
  *
  * `vectorDimensions` is the one number interpolated into the type token, so it
  * is validated here as a positive integer within pgvector's limit rather than
@@ -99,7 +99,7 @@ function resolveDdlType(config, dialect, columnName) {
     return config.isArray ? `${base}[]` : base;
 }
 // ---------------------------------------------------------------------------
-// SQL Generation — SchemaDef → CREATE TABLE statements
+// SQL Generation, SchemaDef → CREATE TABLE statements
 // ---------------------------------------------------------------------------
 /**
  * Convert a SchemaDef into an ordered array of SQL DDL statements.
@@ -114,7 +114,7 @@ function schemaToSQL(schema, options) {
     // Topologically sort tables by their foreign key references
     const sorted = topologicalSort(schema);
     const resolveRef = makeRefResolver(schema);
-    // pgvector extension line — only when a vector column exists. Postgres-only:
+    // pgvector extension line, only when a vector column exists. Postgres-only:
     // a dialect that can't do pgvector must not silently emit broken DDL.
     if (schemaHasVectorColumn(schema)) {
         if (!dialect.supportsVector) {
@@ -198,7 +198,7 @@ function topologicalSort(schema) {
         if (resolved.has(name))
             return;
         if (visiting.has(name)) {
-            // Circular reference — just add it
+            // Circular reference, just add it
             return;
         }
         visiting.add(name);
@@ -268,7 +268,7 @@ function generateCreateTable(table, resolveRef, dialect = dialect_js_1.postgresD
  */
 function generateColumnDef(fieldName, config, resolveRef, dialect = dialect_js_1.postgresDialect) {
     const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
-    // NOT NULL — serial types are implicitly NOT NULL, but explicit is fine.
+    // NOT NULL, serial types are implicitly NOT NULL, but explicit is fine.
     // A column is NOT NULL if:
     //   1. Explicitly marked .notNull(), OR
     //   2. Is a serial (BIGSERIAL implies NOT NULL), OR
@@ -282,7 +282,7 @@ function generateColumnDef(fieldName, config, resolveRef, dialect = dialect_js_1
     if (config.defaultValue != null) {
         defaultValue = normalizeDefault(config.defaultValue);
     }
-    // REFERENCES — resolve the raw table name through the optional resolver so
+    // REFERENCES, resolve the raw table name through the optional resolver so
     // both camelCase accessor names and snake_case DDL names work.
     let references;
     if (config.referencesTarget) {
@@ -511,7 +511,7 @@ function buildAddForeignKeyStatement(table, constraintName, column, targetTable,
 }
 /**
  * Decide whether a FK's referential actions changed. When they differ, returns
- * the DROP + ADD CONSTRAINT statements (and their reverse) — Postgres has no
+ * the DROP + ADD CONSTRAINT statements (and their reverse), Postgres has no
  * `ALTER CONSTRAINT` for referential actions, so drop-and-recreate is the only
  * path. Returns null when the actions already match.
  */
@@ -527,7 +527,7 @@ function diffReferentialAction(table, db, schemaOnDelete, schemaOnUpdate, dialec
 /**
  * Compute append-only enum value changes. Returns `ALTER TYPE ... ADD VALUE`
  * statements for labels present in the schema but not the DB (in order), plus a
- * destructive warning for any DB label the schema dropped or any reorder —
+ * destructive warning for any DB label the schema dropped or any reorder -
  * Postgres cannot remove or reorder enum values without recreating the type.
  */
 function diffEnumValues(enumName, schemaLabels, dbLabels, dialect = dialect_js_1.postgresDialect) {
@@ -543,7 +543,7 @@ function diffEnumValues(enumName, schemaLabels, dbLabels, dialect = dialect_js_1
     const removed = dbLabels.filter((l) => !schemaSet.has(l));
     if (removed.length > 0) {
         warnings.push(`Enum "${enumName}": labels [${removed.join(', ')}] exist in the database but not the schema. ` +
-            `Postgres cannot remove enum values in place — recreate the type manually if intended.`);
+            `Postgres cannot remove enum values in place, recreate the type manually if intended.`);
     }
     return { statements, warnings };
 }
@@ -551,7 +551,7 @@ function diffEnumValues(enumName, schemaLabels, dbLabels, dialect = dialect_js_1
  * Diff a table's CHECK constraints (matched by name). Adds constraints missing
  * from the DB, drops DB constraints absent from the schema, and drop+adds when a
  * same-named constraint's expression changed. Expression comparison is a naive
- * whitespace-insensitive match — semantically-equal-but-different-spelled
+ * whitespace-insensitive match, semantically-equal-but-different-spelled
  * expressions may re-emit (documented; harmless drop+add).
  */
 function diffCheckConstraints(table, schemaChecks, dbChecks, dialect = dialect_js_1.postgresDialect) {
@@ -733,7 +733,7 @@ async function schemaDiff(schema, connectionString) {
                 result.statements.push(...fkIndexes);
                 // User-declared indexes on a brand-new table (reversed by the DROP TABLE).
                 result.statements.push(...generateDeclaredIndexes(tableDef, dialect));
-                // Reverse: DROP TABLE (with indexes — they drop automatically)
+                // Reverse: DROP TABLE (with indexes, they drop automatically)
                 result.reverseStatements.unshift(`DROP TABLE IF EXISTS ${dialect.quoteIdentifier(ddlName)} CASCADE;`);
             }
         }
@@ -757,7 +757,7 @@ async function schemaDiff(schema, connectionString) {
                 const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
                 const dbCol = dbCols[snakeName];
                 if (!dbCol) {
-                    // Column exists in schema but not in DB — ADD COLUMN
+                    // Column exists in schema but not in DB, ADD COLUMN
                     const colDef = generateColumnDef(fieldName, config, resolveRef, dialect);
                     const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ADD COLUMN ${colDef};`;
                     const reverseSql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP COLUMN ${dialect.quoteIdentifier(snakeName)};`;
@@ -770,10 +770,10 @@ async function schemaDiff(schema, connectionString) {
                 // underlying int4/int8 width must never be auto-altered on a live table
                 // (a downcast on a PK loses data / breaks the sequence). This also
                 // preserves back-compat for DBs whose `serial` columns were created as
-                // BIGSERIAL (int8) before 0.24.0 — `push` won't try to shrink them.
+                // BIGSERIAL (int8) before 0.24.0, `push` won't try to shrink them.
                 const expectedUdt = schemaTypeToUdt(config);
                 if (expectedUdt && !isSerialType(config.type) && dbCol.udtName !== expectedUdt) {
-                    // resolveDdlType handles enum names, vector(n), arrays, and VARCHAR(n) —
+                    // resolveDdlType handles enum names, vector(n), arrays, and VARCHAR(n) -
                     // config.type alone would emit the internal ENUM/VECTOR sentinels here.
                     const sqlType = resolveDdlType(config, dialect, snakeName);
                     const oldSqlType = udtToSqlType(dbCol.udtName, dbCol.maxLength);
@@ -833,7 +833,7 @@ async function schemaDiff(schema, connectionString) {
                         result.reverseStatements.unshift(reverseSql);
                     }
                 }
-                // Check UNIQUE constraint mismatch (skip PKs — they're implicitly unique)
+                // Check UNIQUE constraint mismatch (skip PKs, they're implicitly unique)
                 if (!config.isPrimaryKey) {
                     const hasDbUnique = snakeName in tableUniques;
                     const wantsUnique = config.isUnique === true;
@@ -886,7 +886,7 @@ async function schemaDiff(schema, connectionString) {
                 const snakeName = (0, schema_js_1.camelToSnake)(fieldName);
                 const dbFk = tableFks[snakeName];
                 if (!dbFk)
-                    continue; // FK not present in DB yet (or composite) — skip
+                    continue; // FK not present in DB yet (or composite), skip
                 const change = diffReferentialAction(tableName, dbFk, config.onDelete ?? 'no action', config.onUpdate ?? 'no action', dialect);
                 if (change) {
                     result.statements.push(...change.statements);
@@ -900,7 +900,7 @@ async function schemaDiff(schema, connectionString) {
             // inline checks carry auto-generated names the code-first schema never
             // sees), and we do NOT drop+add on expression mismatch: pg_get_constraintdef
             // canonicalizes expressions (casts, ANY(ARRAY[...]) rewrites), so authored
-            // text almost never string-matches the stored form — comparing would emit a
+            // text almost never string-matches the stored form, comparing would emit a
             // spurious full-table-revalidating drop+add on every diff. An apparent
             // mismatch surfaces as a warning instead; rename the constraint to
             // intentionally replace its expression. Unnamed schema checks are skipped
@@ -1078,7 +1078,7 @@ function defaultsMatch(schemaDefault, dbDefault) {
     return a === b;
 }
 // ---------------------------------------------------------------------------
-// Schema Push — execute the diff against a live database
+// Schema Push, execute the diff against a live database
 // ---------------------------------------------------------------------------
 /**
  * Scan a set of diff statements for data-destroying operations, using the same

package/dist/cjs/schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Schema metadata types
+ * turbine-orm, Schema metadata types
  *
  * These types represent the introspected database schema at runtime.
  * They're used by the query builder, code generator, and CLI.
@@ -70,7 +70,7 @@ export interface ColumnMetadata {
     /**
      * Schema the column's Postgres type lives in, recorded by introspection
      * ONLY when it differs from the introspected schema (and isn't a
-     * `pg_catalog` builtin) — e.g. an enum or domain owned by another schema.
+     * `pg_catalog` builtin), e.g. an enum or domain owned by another schema.
      * Consumers use it as a cross-schema guard: a same-named enum in another
      * schema must not receive this schema's `::"enum"` cast (search_path would
      * resolve it to the wrong type). Absent for same-schema types, builtins,
@@ -84,7 +84,7 @@ export interface ColumnMetadata {
     /** Whether the column has a DEFAULT, is serial, or is generated */
     hasDefault: boolean;
     /**
-     * Whether the **database server** generates this column's value on insert —
+     * Whether the **database server** generates this column's value on insert -
      * a `serial`/`BIGSERIAL` sequence, an `IDENTITY` column, or PowDB's `auto`
      * modifier. This is a strict subset of {@link hasDefault} (a server-generated
      * column always reports `hasDefault: true`), but unlike a client-side default
@@ -96,8 +96,8 @@ export interface ColumnMetadata {
     /**
      * True when this is a Postgres **`GENERATED ALWAYS AS (expr) STORED`** column
      * (`information_schema.columns.is_generated = 'ALWAYS'`). Distinct from
-     * {@link isGenerated} — which flags a server-*assigned* identity/serial value
-     * that a client MAY still override — a STORED generated column's value is
+     * {@link isGenerated}, which flags a server-*assigned* identity/serial value
+     * that a client MAY still override, a STORED generated column's value is
      * *computed from other columns* and can NEVER be supplied on insert/update
      * (Postgres rejects it). Codegen therefore omits it from `*Create`/`*Update`
      * input types, and the write builders reject any `data` containing it with a
@@ -120,6 +120,16 @@ export interface ColumnMetadata {
      * Introspection never auto-tags PII (it is a code-first declaration).
      */
     pii?: boolean;
+    /**
+     * True when this column should be set to the current time on every `update`
+     * that does not name it explicitly (Prisma's `@updatedAt`).
+     *
+     * A code-first declaration only (`defineSchema` `updatedAt: true` /
+     * `.updatedAt()`): introspection NEVER infers it from a column's name,
+     * because an application that already manages its own `updated_at` would
+     * silently have its writes changed. Untagged schemas emit byte-identical SQL.
+     */
+    updatedAt?: boolean;
     /** Whether this is an array column */
     isArray: boolean;
     /** Dialect-specific array/bulk-insert type token when needed. */
@@ -159,10 +169,10 @@ export interface RelationDef {
      * For `manyToMany` relations only: the junction (join) table that links the
      * source and target tables. The subquery JOINs the target through this table.
      *
-     *   - `table`     — junction table name (snake_case).
-     *   - `sourceKey` — junction column(s) referencing the SOURCE table's
+     *   - `table`    , junction table name (snake_case).
+     *   - `sourceKey`, junction column(s) referencing the SOURCE table's
      *                   {@link referenceKey} (typically the source PK).
-     *   - `targetKey` — junction column(s) referencing the TARGET table's PK.
+     *   - `targetKey`, junction column(s) referencing the TARGET table's PK.
      *
      * Array forms support composite keys (paired positionally with the
      * referenced columns). Omitted for non-m2m relations.
@@ -246,7 +256,7 @@ export declare function timeOfDayKind(dbType: string | undefined): 'time' | 'tim
  * driver's local-offset serialization is CORRECT for it (Postgres converts the
  * offset away). The two types here store the literal wall-clock fields they
  * are given, so binding a JS `Date` through the driver stores the process's
- * LOCAL calendar fields — in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
+ * LOCAL calendar fields, in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
  * lands as `2026-07-24 17:00:00`. The read path already interprets an
  * offset-less value as UTC (see `parseDbDate`), so the write path has to bind
  * the UTC components for the round trip to be stable.

package/dist/cjs/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * turbine-orm — Schema metadata types
+ * turbine-orm, Schema metadata types
  *
  * These types represent the introspected database schema at runtime.
  * They're used by the query builder, code generator, and CLI.
@@ -38,7 +38,7 @@ const PG_TO_TS = {
     float4: 'number',
     float8: 'number',
     oid: 'number',
-    // Precision-sensitive — keep as string to avoid JS float issues
+    // Precision-sensitive, keep as string to avoid JS float issues
     numeric: 'string',
     money: 'string',
     // Boolean
@@ -79,9 +79,9 @@ const PG_TO_TS = {
     // TSVector
     tsvector: 'string',
     tsquery: 'string',
-    // pgvector — embeddings. Mapped to `number[]` for DX (the natural shape an app
+    // pgvector, embeddings. Mapped to `number[]` for DX (the natural shape an app
     // passes when inserting / comparing embeddings). NOTE: like `numeric` above,
-    // there is a runtime caveat — pg has no built-in parser for the `vector` type,
+    // there is a runtime caveat, pg has no built-in parser for the `vector` type,
     // so over the wire a fetched vector arrives as a string literal like
     // '[1,2,3]' unless the app registers its own parser (e.g. via pgvector's
     // `registerType`). Turbine never auto-registers one (no side-effecting type
@@ -99,7 +99,7 @@ const DATE_TYPES = new Set(['timestamptz', 'timestamp', 'date']);
  * `text`: the `text[]` fallback below then produces text-typed UNNEST output
  * and Postgres refuses the insert with `42804 column "x" is of type <t> but
  * expression is of type text`. `varchar` / `char` / `bpchar` deliberately keep
- * the `text[]` cast — `text` assignment-casts to all three, and pinning them
+ * the `text[]` cast, `text` assignment-casts to all three, and pinning them
  * would change already-emitted SQL for no behavioral gain.
  */
 const PG_TO_ARRAY = {
@@ -223,7 +223,7 @@ function timeOfDayKind(dbType) {
  * driver's local-offset serialization is CORRECT for it (Postgres converts the
  * offset away). The two types here store the literal wall-clock fields they
  * are given, so binding a JS `Date` through the driver stores the process's
- * LOCAL calendar fields — in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
+ * LOCAL calendar fields, in `America/Los_Angeles`, `2026-07-25T00:00:00Z`
  * lands as `2026-07-24 17:00:00`. The read path already interprets an
  * offset-less value as UTC (see `parseDbDate`), so the write path has to bind
  * the UTC components for the round trip to be stable.

package/dist/cjs/serverless.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm/serverless — edge / serverless driver integration
+ * turbine-orm/serverless, edge / serverless driver integration
  *
  * Turbine runs on any Postgres driver that speaks the node-postgres API.
  * This module exposes a thin factory (`turbineHttp`) that binds an external
@@ -12,12 +12,12 @@
  * Any driver whose `Pool` satisfies `PgCompatPool` will work. The ones
  * below are verified:
  *
- * - **Neon** (`@neondatabase/serverless`) — HTTP and WebSocket transports
- * - **Vercel Postgres** (`@vercel/postgres`) — wraps Neon
- * - **Cloudflare Hyperdrive** — exposes a pg-compatible driver
- * - **Supabase** — use the regular `pg` package; Supabase is Postgres-native
+ * - **Neon** (`@neondatabase/serverless`), HTTP and WebSocket transports
+ * - **Vercel Postgres** (`@vercel/postgres`), wraps Neon
+ * - **Cloudflare Hyperdrive**, exposes a pg-compatible driver
+ * - **Supabase**, use the regular `pg` package; Supabase is Postgres-native
  *
- * Turbine does NOT bundle any of these — install whichever you need and
+ * Turbine does NOT bundle any of these, install whichever you need and
  * pass its pool directly.
  *
  * ## Limitations over HTTP
@@ -27,9 +27,9 @@
  *   If you call these on an HTTP pool the underlying driver will error.
  * - **LISTEN/NOTIFY** is not available over HTTP.
  * - **Transactions** are supported but each transaction holds an HTTP
- *   connection for its duration — keep them short.
+ *   connection for its duration, keep them short.
  *
- * ## Example — Neon on Vercel Edge
+ * ## Example, Neon on Vercel Edge
  *
  * ```ts
  * // app/api/users/route.ts
@@ -48,7 +48,7 @@
  * }
  * ```
  *
- * ## Example — Supabase (direct Postgres, no HTTP proxy needed)
+ * ## Example, Supabase (direct Postgres, no HTTP proxy needed)
  *
  * ```ts
  * import { TurbineClient } from 'turbine-orm';
@@ -60,7 +60,7 @@
  * }, SCHEMA);
  * ```
  *
- * ## Example — Cloudflare Workers
+ * ## Example, Cloudflare Workers
  *
  * ```ts
  * // Use the Neon HTTP driver which works in Workers runtime
@@ -92,14 +92,14 @@ export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'def
  *
  * Use this for serverless/edge environments where Turbine should NOT
  * manage its own `pg.Pool`. The caller retains ownership of the pool's
- * lifecycle — `db.disconnect()` is a no-op.
+ * lifecycle, `db.disconnect()` is a no-op.
  *
  * ## Typed table accessors
  *
  * By default `turbineHttp` returns the base {@link TurbineClient}, so you
  * reach tables through `db.table('users')`. To get the *generated*, fully
- * typed accessors (`db.users.findMany()`) — identical to what the TCP-path
- * `turbine()` factory gives you — pass your generated client type as the
+ * typed accessors (`db.users.findMany()`), identical to what the TCP-path
+ * `turbine()` factory gives you, pass your generated client type as the
  * `TClient` type argument. The runtime object is the same; the generated
  * subclass only adds `declare readonly` accessor typings, and the base
  * constructor already creates those accessors at runtime for every table in
@@ -116,7 +116,7 @@ export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'def
  * @param options - Optional logging / defaultLimit / warnOnUnlimited
  * @returns A TurbineClient instance (typed as `TClient`)
  *
- * @example Untyped (back-compat) — reach tables via `db.table(...)`
+ * @example Untyped (back-compat), reach tables via `db.table(...)`
  * ```ts
  * import { Pool } from '@neondatabase/serverless';
  * import { turbineHttp } from 'turbine-orm/serverless';
@@ -127,7 +127,7 @@ export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'def
  * const users = await db.table('users').findMany({ limit: 10 });
  * ```
  *
- * @example Typed — generated accessors, identical to the TCP client
+ * @example Typed, generated accessors, identical to the TCP client
  * ```ts
  * import { Pool } from '@neondatabase/serverless';
  * import { turbineHttp } from 'turbine-orm/serverless';

package/dist/cjs/serverless.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * turbine-orm/serverless — edge / serverless driver integration
+ * turbine-orm/serverless, edge / serverless driver integration
  *
  * Turbine runs on any Postgres driver that speaks the node-postgres API.
  * This module exposes a thin factory (`turbineHttp`) that binds an external
@@ -13,12 +13,12 @@
  * Any driver whose `Pool` satisfies `PgCompatPool` will work. The ones
  * below are verified:
  *
- * - **Neon** (`@neondatabase/serverless`) — HTTP and WebSocket transports
- * - **Vercel Postgres** (`@vercel/postgres`) — wraps Neon
- * - **Cloudflare Hyperdrive** — exposes a pg-compatible driver
- * - **Supabase** — use the regular `pg` package; Supabase is Postgres-native
+ * - **Neon** (`@neondatabase/serverless`), HTTP and WebSocket transports
+ * - **Vercel Postgres** (`@vercel/postgres`), wraps Neon
+ * - **Cloudflare Hyperdrive**, exposes a pg-compatible driver
+ * - **Supabase**, use the regular `pg` package; Supabase is Postgres-native
  *
- * Turbine does NOT bundle any of these — install whichever you need and
+ * Turbine does NOT bundle any of these, install whichever you need and
  * pass its pool directly.
  *
  * ## Limitations over HTTP
@@ -28,9 +28,9 @@
  *   If you call these on an HTTP pool the underlying driver will error.
  * - **LISTEN/NOTIFY** is not available over HTTP.
  * - **Transactions** are supported but each transaction holds an HTTP
- *   connection for its duration — keep them short.
+ *   connection for its duration, keep them short.
  *
- * ## Example — Neon on Vercel Edge
+ * ## Example, Neon on Vercel Edge
  *
  * ```ts
  * // app/api/users/route.ts
@@ -49,7 +49,7 @@
  * }
  * ```
  *
- * ## Example — Supabase (direct Postgres, no HTTP proxy needed)
+ * ## Example, Supabase (direct Postgres, no HTTP proxy needed)
  *
  * ```ts
  * import { TurbineClient } from 'turbine-orm';
@@ -61,7 +61,7 @@
  * }, SCHEMA);
  * ```
  *
- * ## Example — Cloudflare Workers
+ * ## Example, Cloudflare Workers
  *
  * ```ts
  * // Use the Neon HTTP driver which works in Workers runtime
@@ -87,14 +87,14 @@ const client_js_1 = require("./client.js");
  *
  * Use this for serverless/edge environments where Turbine should NOT
  * manage its own `pg.Pool`. The caller retains ownership of the pool's
- * lifecycle — `db.disconnect()` is a no-op.
+ * lifecycle, `db.disconnect()` is a no-op.
  *
  * ## Typed table accessors
  *
  * By default `turbineHttp` returns the base {@link TurbineClient}, so you
  * reach tables through `db.table('users')`. To get the *generated*, fully
- * typed accessors (`db.users.findMany()`) — identical to what the TCP-path
- * `turbine()` factory gives you — pass your generated client type as the
+ * typed accessors (`db.users.findMany()`), identical to what the TCP-path
+ * `turbine()` factory gives you, pass your generated client type as the
  * `TClient` type argument. The runtime object is the same; the generated
  * subclass only adds `declare readonly` accessor typings, and the base
  * constructor already creates those accessors at runtime for every table in
@@ -111,7 +111,7 @@ const client_js_1 = require("./client.js");
  * @param options - Optional logging / defaultLimit / warnOnUnlimited
  * @returns A TurbineClient instance (typed as `TClient`)
  *
- * @example Untyped (back-compat) — reach tables via `db.table(...)`
+ * @example Untyped (back-compat), reach tables via `db.table(...)`
  * ```ts
  * import { Pool } from '@neondatabase/serverless';
  * import { turbineHttp } from 'turbine-orm/serverless';
@@ -122,7 +122,7 @@ const client_js_1 = require("./client.js");
  * const users = await db.table('users').findMany({ limit: 10 });
  * ```
  *
- * @example Typed — generated accessors, identical to the TCP client
+ * @example Typed, generated accessors, identical to the TCP client
  * ```ts
  * import { Pool } from '@neondatabase/serverless';
  * import { turbineHttp } from 'turbine-orm/serverless';
@@ -138,6 +138,6 @@ function turbineHttp(pool, schema, options = {}) {
     // The generated subclass only layers `declare readonly` accessor typings
     // over the base client; the base constructor materializes those same
     // accessors at runtime (Object.defineProperty per schema table). So the
-    // returned instance genuinely has TClient's shape — the assertion is safe.
+    // returned instance genuinely has TClient's shape, the assertion is safe.
     return new client_js_1.TurbineClient({ pool, ...options }, schema);
 }

package/dist/cjs/sqlite.d.ts

@@ -1,16 +1,16 @@
 /**
- * turbine-orm/sqlite — zero-dependency SQLite engine
+ * turbine-orm/sqlite, zero-dependency SQLite engine
  *
  * Binds Turbine to SQLite via Node's built-in `node:sqlite` driver
  * (`DatabaseSync`), so SQLite is a **zero new dependency** engine: the root
  * package's runtime dependency stays exactly `pg`. This is the in-process
- * test / edge / "try it in 10 seconds" engine — `:memory:` databases run
+ * test / edge / "try it in 10 seconds" engine, `:memory:` databases run
  * entirely in-process with no service container.
  *
  * ## Driver
  *
  * - **Primary:** `node:sqlite` `DatabaseSync` (Node ≥ 22.5, experimental). Emits
- *   an `ExperimentalWarning` — harmless. No native build, no extra dependency.
+ *   an `ExperimentalWarning`, harmless. No native build, no extra dependency.
  * - **Fallback:** `better-sqlite3` for Node < 22.5. Not bundled and not required;
  *   wrap a `better-sqlite3` handle in the same `PgCompatPool` shape if needed.
  *
@@ -24,7 +24,7 @@
  *   WAL` is enabled for file databases to allow concurrent readers.
  * - **Unsupported (throw `UnsupportedFeatureError`):** pgvector distance ops,
  *   LISTEN/NOTIFY (`$listen` / `$notify`), RLS `sessionContext`. Advisory-lock
- *   migration locking is unavailable — SQLite is single-writer, so migrations
+ *   migration locking is unavailable, SQLite is single-writer, so migrations
  *   serialize naturally.
  * - **Type affinity caveats:** SQLite has no native `BOOLEAN` (0/1 integers) or
  *   `DATE` (TEXT/INTEGER). Booleans bind as 1/0; `Date` values bind as ISO-8601
@@ -34,7 +34,7 @@
  * - **Case-insensitive matching** uses `COLLATE NOCASE`, which is **ASCII-only**
  *   (no Unicode case folding).
  *
- * ## Example — `:memory:` database
+ * ## Example, `:memory:` database
  *
  * ```ts
  * import { turbineSqlite } from 'turbine-orm/sqlite';
@@ -58,12 +58,12 @@ type QueryArg = string | {
 /**
  * A `PgCompatPool` backed by a single `node:sqlite` `DatabaseSync` connection.
  * SQLite is single-connection by nature (a `:memory:` database is per-handle),
- * so `connect()` hands back a client over the **same** handle — transactions
+ * so `connect()` hands back a client over the **same** handle, transactions
  * (`BEGIN`/`COMMIT`/`ROLLBACK`, `SAVEPOINT` nesting) just run on it. Queries are
  * serialized; this is the documented single-writer model.
  */
 export declare class SqlitePool implements PgCompatPool {
-    /** The underlying `node:sqlite` handle — exposed as an escape hatch (seed/DDL). */
+    /** The underlying `node:sqlite` handle, exposed as an escape hatch (seed/DDL). */
     readonly db: DatabaseSync;
     private closed;
     constructor(db: DatabaseSync);
@@ -116,7 +116,7 @@ export interface TurbineSqliteOptions extends Pick<TurbineConfig, 'logging' | 'd
      * Ignored for `':memory:'`. Default: `true`.
      */
     wal?: boolean;
-    /** `PRAGMA busy_timeout` in ms — how long a writer waits on `SQLITE_BUSY`. Default: 5000. */
+    /** `PRAGMA busy_timeout` in ms, how long a writer waits on `SQLITE_BUSY`. Default: 5000. */
     busyTimeoutMs?: number;
     /** Enable `PRAGMA foreign_keys` enforcement. Default: `true`. */
     foreignKeys?: boolean;