turbine-orm 0.50.0 → 0.51.0

package/dist/dialect.js

@@ -1,11 +1,12 @@
 /**
- * turbine-orm — SQL dialect contract
+ * turbine-orm, SQL dialect contract
  *
  * Phase-1 seam for future database packages. The current package remains
  * PostgreSQL-native by default, but query generation now depends on this
  * contract for the SQL primitives that vary across MySQL and SQLite.
  */
 import { ValidationError } from './errors.js';
+import { coerceJsonWireValue, jsonWireCoercionOid } from './query/utils.js';
 import { pgArrayType, pgTypeToTs } from './schema.js';
 /** PostgreSQL implementation of the dialect contract. */
 export const postgresDialect = {
@@ -80,6 +81,28 @@ export const postgresDialect = {
         if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
             throw new ValidationError('PostgreSQL bulk insert requires one array type per column');
         }
+        // Row-major form: required when a target column is itself array-typed,
+        // because the UNNEST transpose below flattens nested arrays (see
+        // `requireRowValues`). One placeholder per cell instead of per column.
+        if (input.requireRowValues) {
+            const params = [];
+            const tuples = input.rowValues.map((row) => {
+                const cells = input.columns.map((_, i) => {
+                    params.push(row[i]);
+                    // No cast: PostgreSQL infers each parameter's type from the INSERT
+                    // target column, which is what single-row `create` already relies on
+                    // and is what makes arrays and enums both work here. The casts in
+                    // `columnArrayTypes` are ARRAY-OF-column-type, correct for the
+                    // UNNEST transpose below but wrong for an individual cell.
+                    return this.paramPlaceholder(params.length);
+                });
+                return `(${cells.join(', ')})`;
+            });
+            let rowSql = `INSERT INTO ${input.table} (${input.columns.join(', ')}) VALUES ${tuples.join(', ')}`;
+            if (input.skipDuplicates)
+                rowSql += ' ON CONFLICT DO NOTHING';
+            return { sql: `${rowSql}${this.buildReturningClause(input.returning)}`, params };
+        }
         const columnArrays = input.columns.map((_, columnIndex) => input.rowValues.map((row) => row[columnIndex]));
         const unnestArgs = input.columns.map((_, i) => `${this.paramPlaceholder(i + 1)}::${input.columnArrayTypes[i]}`);
         let sql = `INSERT INTO ${input.table} (${input.columns.join(', ')}) SELECT * FROM UNNEST(${unnestArgs.join(', ')})`;
@@ -124,6 +147,21 @@ export const postgresDialect = {
     arrayType(baseType) {
         return pgArrayType(baseType);
     },
+    jsonWireRule(columnType) {
+        // `json_build_object` renders these as a JSON number / bare token that does
+        // not match what the driver returns for the same column (numeric past
+        // double precision and int8 past 2^53 lose digits outright). Carry the
+        // driver's own wire TEXT instead and hand it back to the driver's parser
+        // for that OID, so the join strategy returns exactly what a top-level read
+        // returns.
+        const oid = jsonWireCoercionOid(columnType);
+        if (oid === undefined)
+            return undefined;
+        return {
+            sql: (ref) => `${ref}::text`,
+            decode: (value) => coerceJsonWireValue(oid, value),
+        };
+    },
     buildColumnType(input) {
         if (input.type === 'VARCHAR' && input.maxLength != null) {
             return `VARCHAR(${input.maxLength})`;
@@ -195,7 +233,7 @@ export const postgresDialect = {
         return `ROLLBACK TO SAVEPOINT ${name}`;
     },
     buildSetSessionConfig(name, value) {
-        // set_config(name, value, is_local=true) — the parameterizable,
+        // set_config(name, value, is_local=true), the parameterizable,
         // transaction-local equivalent of `SET LOCAL` (which rejects bind params).
         return {
             sql: `SELECT set_config(${this.paramPlaceholder(1)}, ${this.paramPlaceholder(2)}, true)`,

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Error types
+ * turbine-orm, Error types
  *
  * Typed errors with error codes for programmatic handling.
  * All Turbine errors extend TurbineError which includes a `code` property.
@@ -39,7 +39,7 @@ export declare class TurbineError extends Error {
  *
  * Defaults to `'safe'` to avoid leaking PII into error logs (Sentry, Datadog,
  * etc.). The full `where` object is always available as `err.where` for
- * programmatic access — only the human-readable message is redacted.
+ * programmatic access, only the human-readable message is redacted.
  *
  * Set via `setErrorMessageMode('verbose')` or by constructing TurbineClient
  * with `{ errorMessages: 'verbose' }`.
@@ -182,7 +182,7 @@ export declare class NotNullViolationError extends TurbineError {
 /**
  * Thrown when Postgres detects a deadlock (pg code 40P01).
  *
- * This error is **retryable** — when caught, callers can safely retry the
+ * This error is **retryable**, when caught, callers can safely retry the
  * transaction (typically with backoff). Catch it explicitly:
  *
  * ```ts
@@ -207,9 +207,9 @@ export declare class DeadlockError extends TurbineError {
 }
 /**
  * Thrown when a Serializable transaction fails due to a serialization
- * conflict (pg code 40001 — `could not serialize access due to ...`).
+ * conflict (pg code 40001, `could not serialize access due to ...`).
  *
- * This error is **retryable** — by Postgres documentation, the recommended
+ * This error is **retryable**, by Postgres documentation, the recommended
  * response is to re-run the entire transaction. Catch it explicitly:
  *
  * ```ts

package/dist/errors.js

@@ -1,5 +1,5 @@
 /**
- * turbine-orm — Error types
+ * turbine-orm, Error types
  *
  * Typed errors with error codes for programmatic handling.
  * All Turbine errors extend TurbineError which includes a `code` property.
@@ -140,7 +140,7 @@ export class NotFoundError extends TurbineError {
     where;
     operation;
     constructor(input) {
-        // Back-compat: string argument (or undefined) — replicate legacy behavior.
+        // Back-compat: string argument (or undefined), replicate legacy behavior.
         if (typeof input === 'string' || input === undefined) {
             super(TurbineErrorCode.NOT_FOUND, input ?? 'Record not found');
             this.name = 'NotFoundError';
@@ -255,7 +255,7 @@ export class UniqueConstraintError extends TurbineError {
             // PII-safe by default: the raw pg `detail` string contains the
             // conflicting row VALUES (e.g. `Key (email)=(alice@x.com) already
             // exists.`). Only append it in 'verbose' mode. In 'safe' mode the
-            // message carries keys/constraint/column names only — the structured
+            // message carries keys/constraint/column names only, the structured
             // `.columns`/`.constraint`/`.column` fields and `.cause` still expose
             // the full detail for programmatic use.
             const detail = errorMessageMode === 'verbose' ? detailFromCause(cause) : undefined;
@@ -282,7 +282,7 @@ export class ForeignKeyError extends TurbineError {
             // PII-safe by default: the raw pg `detail` string contains the
             // conflicting row VALUES (e.g. `Key (email)=(alice@x.com) already
             // exists.`). Only append it in 'verbose' mode. In 'safe' mode the
-            // message carries keys/constraint/column names only — the structured
+            // message carries keys/constraint/column names only, the structured
             // `.columns`/`.constraint`/`.column` fields and `.cause` still expose
             // the full detail for programmatic use.
             const detail = errorMessageMode === 'verbose' ? detailFromCause(cause) : undefined;
@@ -308,7 +308,7 @@ export class NotNullViolationError extends TurbineError {
             // PII-safe by default: the raw pg `detail` string contains the
             // conflicting row VALUES (e.g. `Key (email)=(alice@x.com) already
             // exists.`). Only append it in 'verbose' mode. In 'safe' mode the
-            // message carries keys/constraint/column names only — the structured
+            // message carries keys/constraint/column names only, the structured
             // `.columns`/`.constraint`/`.column` fields and `.cause` still expose
             // the full detail for programmatic use.
             const detail = errorMessageMode === 'verbose' ? detailFromCause(cause) : undefined;
@@ -324,7 +324,7 @@ export class NotNullViolationError extends TurbineError {
 /**
  * Thrown when Postgres detects a deadlock (pg code 40P01).
  *
- * This error is **retryable** — when caught, callers can safely retry the
+ * This error is **retryable**, when caught, callers can safely retry the
  * transaction (typically with backoff). Catch it explicitly:
  *
  * ```ts
@@ -355,9 +355,9 @@ export class DeadlockError extends TurbineError {
 }
 /**
  * Thrown when a Serializable transaction fails due to a serialization
- * conflict (pg code 40001 — `could not serialize access due to ...`).
+ * conflict (pg code 40001, `could not serialize access due to ...`).
  *
- * This error is **retryable** — by Postgres documentation, the recommended
+ * This error is **retryable**, by Postgres documentation, the recommended
  * response is to re-run the entire transaction. Catch it explicitly:
  *
  * ```ts
@@ -399,7 +399,7 @@ export class CheckConstraintError extends TurbineError {
             // PII-safe by default: the raw pg `detail` string contains the
             // conflicting row VALUES (e.g. `Key (email)=(alice@x.com) already
             // exists.`). Only append it in 'verbose' mode. In 'safe' mode the
-            // message carries keys/constraint/column names only — the structured
+            // message carries keys/constraint/column names only, the structured
             // `.columns`/`.constraint`/`.column` fields and `.cause` still expose
             // the full detail for programmatic use.
             const detail = errorMessageMode === 'verbose' ? detailFromCause(cause) : undefined;
@@ -424,7 +424,7 @@ export class ExclusionConstraintError extends TurbineError {
             // PII-safe by default: the raw pg `detail` string contains the
             // conflicting row VALUES (e.g. `Key (email)=(alice@x.com) already
             // exists.`). Only append it in 'verbose' mode. In 'safe' mode the
-            // message carries keys/constraint/column names only — the structured
+            // message carries keys/constraint/column names only, the structured
             // `.columns`/`.constraint`/`.column` fields and `.cause` still expose
             // the full detail for programmatic use.
             const detail = errorMessageMode === 'verbose' ? detailFromCause(cause) : undefined;
@@ -482,7 +482,7 @@ export class OptimisticLockError extends TurbineError {
     versionField;
     expectedVersion;
     constructor(opts) {
-        super(TurbineErrorCode.OPTIMISTIC_LOCK, `[turbine] Optimistic lock failed on "${opts.table}" — ` +
+        super(TurbineErrorCode.OPTIMISTIC_LOCK, `[turbine] Optimistic lock failed on "${opts.table}", ` +
             `expected ${opts.versionField} = ${opts.expectedVersion} but row was modified by another transaction`);
         this.name = 'OptimisticLockError';
         this.table = opts.table;

package/dist/generate.d.ts

@@ -1,10 +1,10 @@
 /**
- * turbine-orm — Code generator
+ * turbine-orm, Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
- *   - types.ts     — Entity interfaces, Create/Update input types
- *   - metadata.ts  — Runtime schema metadata (column maps, relations, etc.)
- *   - index.ts     — Configured TurbineClient with typed table accessors
+ *   - types.ts    , Entity interfaces, Create/Update input types
+ *   - metadata.ts , Runtime schema metadata (column maps, relations, etc.)
+ *   - index.ts    , Configured TurbineClient with typed table accessors
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
@@ -19,13 +19,13 @@ export interface GenerateOptions {
     /**
      * Also emit `zod.ts` with per-table `XSchema` / `XCreateSchema` /
      * `XUpdateSchema` Zod validators (H1). The file imports the user-side `zod`
-     * package — it is never imported by Turbine's runtime, so Zod stays out of the
+     * package, it is never imported by Turbine's runtime, so Zod stays out of the
      * library's dependency graph. Default: `false`.
      */
     zod?: boolean;
     /**
      * Omit the `Generated at: <ISO timestamp>` line from every generated file
-     * header (T-8b — reproducible codegen). With this set, byte-identical
+     * header (T-8b, reproducible codegen). With this set, byte-identical
      * schemas regenerate to byte-identical output, so regens produce empty
      * diffs. Default: `false` (timestamp included, unchanged behavior).
      */

package/dist/generate.js

@@ -1,10 +1,10 @@
 /**
- * turbine-orm — Code generator
+ * turbine-orm, Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
- *   - types.ts     — Entity interfaces, Create/Update input types
- *   - metadata.ts  — Runtime schema metadata (column maps, relations, etc.)
- *   - index.ts     — Configured TurbineClient with typed table accessors
+ *   - types.ts    , Entity interfaces, Create/Update input types
+ *   - metadata.ts , Runtime schema metadata (column maps, relations, etc.)
+ *   - index.ts    , Configured TurbineClient with typed table accessors
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
@@ -66,7 +66,7 @@ function escSQ(value) {
 // ---------------------------------------------------------------------------
 export function generate(options) {
     const outDir = options.outDir ?? './generated/turbine';
-    // Path traversal protection — ensure output stays within project root
+    // Path traversal protection, ensure output stays within project root
     const resolved = resolve(outDir);
     const rel = relative(process.cwd(), resolved);
     if (rel.startsWith('..') || resolve(rel) !== resolved) {
@@ -92,7 +92,7 @@ export function generate(options) {
     const indexContent = generateIndex(schema, fileOptions);
     writeFileSync(join(outDir, 'index.ts'), indexContent, 'utf-8');
     files.push('index.ts');
-    // Generate zod.ts (optional — --zod flag)
+    // Generate zod.ts (optional, --zod flag)
     if (options.zod) {
         const zodContent = generateZod(schema, fileOptions);
         writeFileSync(join(outDir, 'zod.ts'), zodContent, 'utf-8');
@@ -251,7 +251,7 @@ function generatedFileHeader(options) {
     // unchanged schema produces byte-identical files.
     return [
         '/**',
-        ' * Auto-generated by turbine-orm — DO NOT EDIT',
+        ' * Auto-generated by turbine-orm, DO NOT EDIT',
         ' *',
         ...(options?.noTimestamp ? [] : [` * Generated at: ${new Date().toISOString()}`]),
         ' * @see https://turbineorm.dev',
@@ -265,7 +265,7 @@ function generatedFileHeader(options) {
  * column: `interface XWithY extends X` becomes TS2430, the `XCreate & { y?: … }`
  * intersection collapses (TS2322), and neither the column nor the relation is
  * targetable. Introspection no longer produces such names (they are
- * disambiguated at the source), but hand-written or legacy metadata may —
+ * disambiguated at the source), but hand-written or legacy metadata may -
  * skip those relations here with a warning instead of emitting broken types.
  * The runtime metadata (metadata.ts) still carries every relation.
  */
@@ -275,7 +275,7 @@ function typeSafeRelations(table, warn = true) {
     for (const [relName, rel] of Object.entries(table.relations)) {
         if (columnFields.has(relName)) {
             if (warn) {
-                console.warn(`[turbine] Relation "${relName}" on table "${table.name}" shadows a column field of the same name — ` +
+                console.warn(`[turbine] Relation "${relName}" on table "${table.name}" shadows a column field of the same name, ` +
                     `omitting it from the generated types. Rename the relation (or the column) to expose it.`);
             }
             continue;
@@ -349,7 +349,7 @@ export function generateTypes(schema, options) {
         lines.push(`/** Input type for creating a row in \`${table.name}\` */`);
         lines.push(`export type ${typeName}Create = {`);
         for (const col of table.columns) {
-            // STORED generated columns are computed by the database — never writable.
+            // STORED generated columns are computed by the database, never writable.
             if (col.isGeneratedStored)
                 continue;
             const isPk = table.primaryKey.includes(col.name);
@@ -381,7 +381,7 @@ export function generateTypes(schema, options) {
         // Each relation is emitted as a `RelationDescriptor<Target, Cardinality,
         // TargetRelations>` brand-field interface. This is what enables the
         // recursive `WithResult` type to walk through nested `with` clauses at
-        // any depth — `RelationRelations<R[K]>` reads the third type parameter
+        // any depth, `RelationRelations<R[K]>` reads the third type parameter
         // and threads it into the next recursion step. If the target table has
         // no relations of its own, the descriptor uses `{}` (the default).
         const safeRelations = safeRelationsByTable.get(table.name) ?? [];
@@ -425,7 +425,7 @@ export function generateTypes(schema, options) {
         const typeName = entityName(table.name);
         const safeRelations = safeRelationsByTable.get(table.name) ?? [];
         const hasRels = safeRelations.length > 0;
-        // WhereUnique — union of unique constraint shapes, deduplicating PK
+        // WhereUnique, union of unique constraint shapes, deduplicating PK
         const seen = new Set();
         const uniqueSets = [];
         // Always include the primary key first
@@ -502,7 +502,7 @@ export function generateTypes(schema, options) {
             lines.push(`export type ${typeName}WhereUnique = ${branches.join(' | ')};`);
             lines.push('');
         }
-        // CreateInput / UpdateInput — extends base type with optional relation fields
+        // CreateInput / UpdateInput, extends base type with optional relation fields
         if (hasRels) {
             lines.push(`export type ${typeName}CreateInput = ${typeName}Create & {`);
             for (const [relName, rel] of safeRelations) {
@@ -556,11 +556,11 @@ export function generateTypes(schema, options) {
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------
-// zod.ts generator (H1 — `turbine generate --zod`)
+// zod.ts generator (H1, `turbine generate --zod`)
 // ---------------------------------------------------------------------------
 /**
  * Map a TypeScript primitive (as produced by {@link pgTypeToTs}) to its Zod
- * expression. `Date` uses `z.coerce.date()` — the generated schemas double as
+ * expression. `Date` uses `z.coerce.date()`, the generated schemas double as
  * request-body validators where dates arrive as ISO strings, and coercion keeps
  * both a `Date` and a valid date-string acceptable (documented decision).
  */
@@ -579,7 +579,7 @@ function zodScalar(ts) {
         case 'Buffer':
             return 'z.instanceof(Uint8Array)';
         case 'number[]':
-            // pgvector — `pgTypeToTs('vector')` yields `number[]`.
+            // pgvector, `pgTypeToTs('vector')` yields `number[]`.
             return 'z.array(z.number())';
         default:
             // json/jsonb and any unmapped user-defined type.
@@ -589,7 +589,7 @@ function zodScalar(ts) {
 /**
  * Base Zod expression for a column, resolving enums → `z.enum([...])`, arrays →
  * `.array()`, and vectors → `z.array(z.number())`. Does NOT append
- * `.nullable()` / `.optional()` — callers layer those on per-schema.
+ * `.nullable()` / `.optional()`, callers layer those on per-schema.
  *
  * `forWrite` mirrors {@link writeColumnTsType}: the Create/Update schemas
  * validate WRITE input, where a `time` / `timetz` column also accepts a JS
@@ -624,7 +624,7 @@ function zodBaseType(col, enums, forWrite = false) {
  */
 export function generateZod(schema, options) {
     const lines = [...generatedFileHeader(options)];
-    // `zod` is a USER dependency — this generated file imports it, but the Turbine
+    // `zod` is a USER dependency, this generated file imports it, but the Turbine
     // library runtime never does, so Zod stays out of the package's dep graph.
     lines.push("import { z } from 'zod';");
     lines.push('');
@@ -641,7 +641,7 @@ export function generateZod(schema, options) {
         }
         lines.push('});');
         lines.push('');
-        // Create schema — STORED generated columns can never be written; PK,
+        // Create schema, STORED generated columns can never be written; PK,
         // defaulted, and nullable columns are optional.
         lines.push(`/** Zod schema for creating a \`${table.name}\` row */`);
         lines.push(`export const ${typeName}CreateSchema = z.object({`);
@@ -658,7 +658,7 @@ export function generateZod(schema, options) {
         }
         lines.push('});');
         lines.push('');
-        // Update schema — PK and STORED generated columns omitted; all else optional.
+        // Update schema, PK and STORED generated columns omitted; all else optional.
         lines.push(`/** Zod schema for updating a \`${table.name}\` row */`);
         lines.push(`export const ${typeName}UpdateSchema = z.object({`);
         for (const col of table.columns) {
@@ -740,7 +740,7 @@ export function generateMetadata(schema, options) {
             const refLiteral = Array.isArray(rel.referenceKey)
                 ? `[${rel.referenceKey.map((c) => `'${escSQ(c)}'`).join(', ')}]`
                 : `'${escSQ(rel.referenceKey)}'`;
-            // manyToMany relations carry a `through` junction descriptor — emit it so
+            // manyToMany relations carry a `through` junction descriptor, emit it so
             // the runtime query builder can JOIN through the junction table.
             let throughLiteral = '';
             if (rel.through) {
@@ -774,7 +774,7 @@ export function generateMetadata(schema, options) {
             }
             lines.push('      ],');
         }
-        // isView — read-only marker; the runtime write guard reads it.
+        // isView, read-only marker; the runtime write guard reads it.
         if (table.isView)
             lines.push('      isView: true,');
         lines.push('    },');
@@ -827,7 +827,7 @@ export function generateIndex(schema, options) {
     lines.push(`import type { ${typeImports.join(', ')} } from './types${ext}';`);
     lines.push('');
     // -------------------------------------------------------------------------
-    // TypedTransactionClient — same typed table accessors as TurbineClient,
+    // TypedTransactionClient, same typed table accessors as TurbineClient,
     // but scoped to a single transaction connection. The runtime instance is
     // an ordinary `TransactionClient` from turbine-orm; this declaration just
     // teaches TypeScript about the auto-attached accessors so users get
@@ -835,7 +835,7 @@ export function generateIndex(schema, options) {
     // -------------------------------------------------------------------------
     lines.push('/**');
     lines.push(' * Transaction-scoped client with the same typed table accessors as TurbineClient.');
-    lines.push(' * Created automatically by `db.$transaction(async (tx) => ...)` — never instantiate');
+    lines.push(' * Created automatically by `db.$transaction(async (tx) => ...)`, never instantiate');
     lines.push(' * directly. All queries run on a dedicated connection within a BEGIN/COMMIT block.');
     lines.push(' */');
     lines.push('export class TypedTransactionClient extends BaseTransactionClient {');
@@ -900,7 +900,7 @@ export function generateIndex(schema, options) {
     // so users get autocomplete on `tx.users`, `tx.posts`, etc.
     //
     // IMPORTANT: the merged member must be compatible with the base class's
-    // $transaction ON ITS OWN (TS2415) — since v0.26 the base method also has a
+    // $transaction ON ITS OWN (TS2415), since v0.26 the base method also has a
     // batch-array overload (`$transaction([...queries])`), so the merged
     // interface must redeclare BOTH signatures. Emitting only the callback form
     // makes every generated client fail `tsc` with "incorrectly extends".
@@ -1030,7 +1030,7 @@ function serializeColumn(col) {
         `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
-    // Cross-schema type marker — introspection records it only for types living
+    // Cross-schema type marker, introspection records it only for types living
     // outside the introspected schema; it must survive codegen or the runtime
     // enum-cast guard in query/builder.ts loses the signal (N-5).
     if (col.pgTypeSchema !== undefined)
@@ -1039,7 +1039,7 @@ function serializeColumn(col) {
     // output stays byte-identical for the common client-default columns.
     if (col.isGenerated)
         parts.push(`isGenerated: true`);
-    // STORED generated columns — the runtime write guard reads isGeneratedStored.
+    // STORED generated columns, the runtime write guard reads isGeneratedStored.
     if (col.isGeneratedStored)
         parts.push(`isGeneratedStored: true`);
     if (col.generationExpression !== undefined) {
@@ -1050,6 +1050,8 @@ function serializeColumn(col) {
     // object built from `defineSchema` (pii: true) carries it through codegen.
     if (col.pii)
         parts.push(`pii: true`);
+    if (col.updatedAt)
+        parts.push(`updatedAt: true`);
     if (col.maxLength !== undefined)
         parts.push(`maxLength: ${col.maxLength}`);
     return `{ ${parts.join(', ')} }`;
@@ -1065,7 +1067,7 @@ function snakeToCamelStr(s) {
  * `T | UpdateOperatorInput<number> | null?` so users can write atomic
  * operators (`{ increment: 1 }`, `{ multiply: 2 }`, etc.) without casts.
  *
- * The check is purely structural — if the column's TS type contains
+ * The check is purely structural, if the column's TS type contains
  * `'number'` (e.g. `number`, `number | null`), it's eligible. Other
  * scalar types (`string`, `boolean`, `Date`, `unknown`, `Buffer`,
  * `Date | null`, etc.) pass through unchanged.
@@ -1079,7 +1081,7 @@ function updateFieldType(tsType) {
 }
 /**
  * Detect whether a TypeScript type expression contains the `number` primitive
- * as a top-level union member. Conservative on purpose — only matches
+ * as a top-level union member. Conservative on purpose, only matches
  * `number`, `number | null`, `null | number`, etc., not `number[]` or
  * `Record<string, number>`.
  */

package/dist/index-advisor.d.ts

@@ -1,11 +1,11 @@
 /**
- * Index advisor — finds relation probes that lack index support.
+ * Index advisor, finds relation probes that lack index support.
  *
  * Turbine loads `with` relations as correlated subqueries: for every parent row,
  * the child table is probed by its FK column(s) (`child.fk = parent.pk`). Relation
  * filters (`some`/`none`/`every`, `is`/`isNot`) probe the same columns. This
  * strategy outperforms batched loading (`WHERE fk IN (ids)`) when the probed
- * column is indexed — but with NO index, each probe is a full table scan and the
+ * column is indexed, but with NO index, each probe is a full table scan and the
  * cost multiplies by the parent rowcount, while batched loading would pay the
  * scan only once. A missing FK index that is invisible under a batched-loader
  * ORM becomes pathological under a correlated one.
@@ -27,7 +27,7 @@ export interface RelationProbe {
 export interface MissingRelationIndex {
     /** Table that gets probed per parent row */
     table: string;
-    /** Probed column(s) — equality lookups, so a covering index must LEAD with one of them */
+    /** Probed column(s), equality lookups, so a covering index must LEAD with one of them */
     columns: string[];
     /** Every relation that generates this probe */
     probes: RelationProbe[];
@@ -46,7 +46,7 @@ export interface CreateIndexSqlOptions {
      * it must also carry the `-- turbine:no-transaction` directive.
      */
     concurrently?: boolean;
-    /** Emit `IF NOT EXISTS` (default true — required for idempotent no-transaction migrations). */
+    /** Emit `IF NOT EXISTS` (default true, required for idempotent no-transaction migrations). */
     ifNotExists?: boolean;
     /**
      * Emit a partial index `... WHERE <col> IS NOT NULL`. Only applied for a
@@ -134,7 +134,7 @@ export declare function schemaHasIndexInfo(schema: SchemaMetadata): boolean;
  * Single-relation check for the dev-mode runtime warning: the (table, columns)
  * this relation probes and whether that probe is unindexed. Returns null when
  * indexed, unknown, or when the schema carries no index info at all (metadata
- * built without introspection — warning would be a blanket false positive).
+ * built without introspection, warning would be a blanket false positive).
  */
 export declare function missingIndexForRelation(schema: SchemaMetadata, relDef: {
     name: string;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * turbine-orm
  *
- * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
+ * Turbine TypeScript SDK, type-safe Postgres queries with nested relations
  * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
  *
  * @example

package/dist/index.js

@@ -1,7 +1,7 @@
 /**
  * turbine-orm
  *
- * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
+ * Turbine TypeScript SDK, type-safe Postgres queries with nested relations
  * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
  *
  * @example
@@ -50,21 +50,21 @@ export { HttpJsonSink, PgMetricsSink, } from './observe.js';
 export { executePipeline, pipelineSupported } from './pipeline.js';
 // Query builder
 export { AUTO_ASSUMED_ROUND_TRIP_MS, AUTO_JOIN_PENALTY_MS_PER_ROW, AUTO_TO_ONE_JOIN_MAX_ROWS, AUTO_TO_ONE_JOIN_ROWS_MAX, AUTO_TO_ONE_JOIN_ROWS_MIN, QueryInterface, } from './query/index.js';
-// Realtime — LISTEN/NOTIFY pub/sub
+// Realtime, LISTEN/NOTIFY pub/sub
 export { validateChannel } from './realtime.js';
 // Schema utilities
 export { camelToSnake, isDateType, normalizeKeyColumns, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, withDbFieldNames, } from './schema.js';
-// Schema builder — define schemas in TypeScript
+// Schema builder, define schemas in TypeScript
 export { applyManyToManyRelations, ColumnBuilder, column, defineSchema, isDocFieldIndexDef, 
-// Legacy compat (deprecated — use object format with defineSchema)
+// Legacy compat (deprecated, use object format with defineSchema)
 table, } from './schema-builder.js';
-// Schema metadata bridge — defineSchema() → SchemaMetadata without a live DB
+// Schema metadata bridge, defineSchema() → SchemaMetadata without a live DB
 export { schemaDefToMetadata } from './schema-metadata.js';
-// Schema SQL — generate DDL, diff, and push
+// Schema SQL, generate DDL, diff, and push
 export { DestructivePushRefusal, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
 // Seed helper
 export { defineSeed } from './seed.js';
 // Serverless / edge factory
 export { turbineHttp } from './serverless.js';
-// Typed raw SQL — Turbine's TypedSQL escape hatch
+// Typed raw SQL, Turbine's TypedSQL escape hatch
 export { buildTypedSql, TypedSqlQuery } from './typed-sql.js';