turbine-orm 0.76.0 → 0.77.0

package/dist/query/where.js

@@ -533,7 +533,7 @@ allowFullTableScan) {
         return;
     if (allowFullTableScan === true)
         return;
-    throw new ValidationError(`[turbine] ${operation} on "${qi.table}" refused: the \`where\` clause is empty. ` +
+    throw new ValidationError(`${operation} on "${qi.table}" refused: the \`where\` clause is empty. ` +
         "Pass `allowFullTableScan: UNSAFE` to opt in (import { UNSAFE } from 'turbine-orm'), " +
         'or check that your filter values are defined.');
 }
@@ -625,13 +625,13 @@ export function buildScalarClause(qi, key, value, params, andClauses) {
             // A JSON-only operator on a non-JSON column was almost certainly a typo
             // or schema mismatch. `contains`/`equals` are shared with WhereOperator
             // (LIKE / equality), so only shape-unique keys reach here.
-            throw new ValidationError(`[turbine] Column "${rawColumn}" on table "${qi.table}" is not a JSON column ` +
+            throw new ValidationError(`Column "${rawColumn}" on table "${qi.table}" is not a JSON column ` +
                 `(actual type: ${getColumnPgType(qi, rawColumn)}); cannot apply JSON operator '${cls.jsonKey}'.`);
         case 'array':
             andClauses.push(...buildArrayFilterClauses(qi, column, value, params, cls.colType));
             return;
         case 'arrayThrow':
-            throw new ValidationError(`[turbine] Column "${rawColumn}" on table "${qi.table}" is not an array column ` +
+            throw new ValidationError(`Column "${rawColumn}" on table "${qi.table}" is not an array column ` +
                 `(actual type: ${getColumnPgType(qi, rawColumn)}); cannot apply array operator '${cls.arrayKey}'.`);
         case 'textsearch':
             andClauses.push(buildTextSearchClause(qi, column, value, params));
@@ -689,7 +689,7 @@ export function relationWhereScope(qi, targetTable, meta) {
         qualifier: `${qi.q(targetTable)}.`,
         relationParent: targetTable,
         host: scopedWhereHost(qi, meta),
-        unknownColumn: (field) => new ValidationError(`[turbine] Unknown field "${field}" in relation filter for table "${targetTable}". ` +
+        unknownColumn: (field) => new ValidationError(`Unknown field "${field}" in relation filter for table "${targetTable}". ` +
             `Known fields: ${Object.keys(meta.columnMap).join(', ') || '(none)'}.`),
     };
 }
@@ -701,7 +701,7 @@ export function aliasWhereScope(qi, targetTable, meta, alias) {
         qualifier: `${alias}.`,
         relationParent: alias,
         host: scopedWhereHost(qi, meta),
-        unknownColumn: (field) => new ValidationError(`[turbine] Unknown column "${field}" in where for table "${targetTable}"`),
+        unknownColumn: (field) => new ValidationError(`Unknown column "${field}" in where for table "${targetTable}"`),
     };
 }
 /**
@@ -776,7 +776,7 @@ export function buildScopedScalarClause(qi, scope, field, value, params, clauses
         }
         const jsonKey = findJsonUniqueKey(value);
         if (jsonKey) {
-            throw new ValidationError(`[turbine] Column "${col}" on table "${scope.table}" is not a JSON column ` +
+            throw new ValidationError(`Column "${col}" on table "${scope.table}" is not a JSON column ` +
                 `(actual type: ${colType}); cannot apply JSON operator '${jsonKey}'.`);
         }
     }
@@ -788,7 +788,7 @@ export function buildScopedScalarClause(qi, scope, field, value, params, clauses
         }
         const arrayKey = findArrayUniqueKey(value);
         if (arrayKey) {
-            throw new ValidationError(`[turbine] Column "${col}" on table "${scope.table}" is not an array column ` +
+            throw new ValidationError(`Column "${col}" on table "${scope.table}" is not an array column ` +
                 `(actual type: ${colType}); cannot apply array operator '${arrayKey}'.`);
         }
     }
@@ -929,23 +929,23 @@ depth = 0) {
         // nested relation filters inside the branch keep their qualification. The
         // fragment binds no params, so collectRelationFilterParams needs no mirror.
         if (!relDef.through) {
-            throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
+            throw new ValidationError(`manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
         }
         const qJunction = qi.q(relDef.through.table);
         const targetKeys = normalizeKeyColumns(relDef.through.targetKey);
         const targetPk = targetMeta.primaryKey;
         if (targetPk.length === 0) {
-            throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}" targets table "${targetTable}" which has no primary key; ` +
+            throw new ValidationError(`manyToMany relation "${relDef.name}" targets table "${targetTable}" which has no primary key; ` +
                 `cannot correlate the relation filter through the junction.`);
         }
         if (targetKeys.length !== targetPk.length) {
-            throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.targetKey has ${targetKeys.length} column(s) ` +
+            throw new ValidationError(`manyToMany relation "${relDef.name}": through.targetKey has ${targetKeys.length} column(s) ` +
                 `but target "${targetTable}" primary key has ${targetPk.length}. Composite keys must pair positionally.`);
         }
         const sourceKeys = normalizeKeyColumns(relDef.through.sourceKey);
         const refKeys = normalizeKeyColumns(relDef.referenceKey);
         if (sourceKeys.length !== refKeys.length) {
-            throw new ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.sourceKey has ${sourceKeys.length} column(s) ` +
+            throw new ValidationError(`manyToMany relation "${relDef.name}": through.sourceKey has ${sourceKeys.length} column(s) ` +
                 `but referenceKey has ${refKeys.length}. Composite keys must pair positionally.`);
         }
         const targetLink = targetKeys
@@ -1134,9 +1134,9 @@ export function assertBindableEqualityValue(qi, rawColumn, value, columnPgType,
         return;
     const badKeys = Object.keys(value);
     throw new ValidationError(badKeys.length === 0
-        ? `[turbine] Empty filter object on "${rawColumn}" for table "${table}". ` +
+        ? `Empty filter object on "${rawColumn}" for table "${table}". ` +
             `Provide a value or an operator like { gt: 1 }.`
-        : `[turbine] Unknown operator${badKeys.length > 1 ? 's' : ''} ` +
+        : `Unknown operator${badKeys.length > 1 ? 's' : ''} ` +
             `${badKeys.map((k) => `"${k}"`).join(', ')} on "${rawColumn}" for table "${table}". ` +
             `Supported operators: ${[...OPERATOR_KEYS].join(', ')}.`);
 }
@@ -1179,13 +1179,13 @@ export function fingerprintAliasWhere(qi, where, targetTable) {
  */
 export function resolveColumnRef(_qi, ref, ctx, mode) {
     if (mode === 'insensitive') {
-        throw new ValidationError(`[turbine] mode: 'insensitive' cannot be combined with a column reference ({ col: "${ref.col}" }). ` +
+        throw new ValidationError(`mode: 'insensitive' cannot be combined with a column reference ({ col: "${ref.col}" }). ` +
             `Case-insensitive column-to-column comparison is not supported: use client.sql\`...\` ` +
             `for lower(a) = lower(b).`);
     }
     const col = resolveColumnName(ctx.meta, ref.col);
     if (col === undefined) {
-        throw new ValidationError(`[turbine] Unknown field "${ref.col}" referenced by { col } in where on table "${ctx.table}". ` +
+        throw new ValidationError(`Unknown field "${ref.col}" referenced by { col } in where on table "${ctx.table}". ` +
             `Known fields: ${Object.keys(ctx.meta.columnMap).join(', ') || '(none)'}.`);
     }
     return col;
@@ -1197,7 +1197,7 @@ export function resolveColumnRef(_qi, ref, ctx, mode) {
  */
 export function columnRefSql(qi, ref, ctx, mode) {
     if (!ctx) {
-        throw new ValidationError(`[turbine] Column reference { col: "${ref.col}" } is not supported in this filter context.`);
+        throw new ValidationError(`Column reference { col: "${ref.col}" } is not supported in this filter context.`);
     }
     return `${ctx.prefix}${qi.q(resolveColumnRef(qi, ref, ctx, mode))}`;
 }
@@ -1366,7 +1366,7 @@ export function vectorOperator(qi, field, rawColumn, metric) {
     }
     const colType = getColumnPgType(qi, rawColumn);
     if (colType !== 'vector') {
-        throw new ValidationError(`[turbine] Column "${field}" on table "${qi.table}" is not a vector column ` +
+        throw new ValidationError(`Column "${field}" on table "${qi.table}" is not a vector column ` +
             `(actual type: ${colType}); cannot apply a vector distance operation.`);
     }
     // ownLookup, not a bare index: an inherited Object.prototype member
@@ -1374,7 +1374,7 @@ export function vectorOperator(qi, field, rawColumn, metric) {
     // and be spliced into the ORDER BY / WHERE clause as its source text.
     const op = ownLookup(VECTOR_METRIC_OPERATORS, metric);
     if (!op) {
-        throw new ValidationError(`[turbine] Unknown vector metric "${metric}" for column "${field}". ` +
+        throw new ValidationError(`Unknown vector metric "${metric}" for column "${field}". ` +
             `Valid metrics: ${Object.keys(VECTOR_METRIC_OPERATORS).join(', ')}.`);
     }
     return op;
@@ -1391,11 +1391,11 @@ export function pushVectorParam(qi, field, _rawColumn, to, params) {
         throw new UnsupportedFeatureError('pgvector distance operations', qi.dialect.name, 'Vector search requires PostgreSQL with the pgvector extension.');
     }
     if (!Array.isArray(to) || to.length === 0) {
-        throw new ValidationError(`[turbine] Vector distance on "${field}" requires a non-empty array of numbers for "to".`);
+        throw new ValidationError(`Vector distance on "${field}" requires a non-empty array of numbers for "to".`);
     }
     for (const el of to) {
         if (typeof el !== 'number' || !Number.isFinite(el)) {
-            throw new ValidationError(`[turbine] Vector "to" for column "${field}" must contain only finite numbers; ` + `got ${JSON.stringify(el)}.`);
+            throw new ValidationError(`Vector "to" for column "${field}" must contain only finite numbers; ` + `got ${JSON.stringify(el)}.`);
         }
     }
     // Bind as a pgvector text literal '[1,2,3]'. Elements are already validated
@@ -1501,14 +1501,14 @@ export function assertJsonFilterKeys(filter, column) {
         if (JSON_FILTER_KEYS.has(key))
             continue;
         const suggestion = JSON_PRISMA_SPELLINGS[key];
-        throw new ValidationError(`[turbine] Unknown JSON filter operator "${key}" on ${column}.` +
+        throw new ValidationError(`Unknown JSON filter operator "${key}" on ${column}.` +
             (suggestion ? ` Did you mean \`${suggestion}\`?` : '') +
             ` Supported operators: ${[...JSON_FILTER_KEYS].sort().join(', ')}.`);
     }
     // `mode` and `path` are modifiers, not comparisons: a filter made only of
     // those compares nothing, which is exactly the silent no-op shape above.
     if (present.length > 0 && present.every((k) => k === 'path' || k === 'mode')) {
-        throw new ValidationError(`[turbine] JSON filter on ${column} selects a \`path\` but has no comparison. ` +
+        throw new ValidationError(`JSON filter on ${column} selects a \`path\` but has no comparison. ` +
             `Add one of: ${[...JSON_FILTER_KEYS]
                 .filter((k) => k !== 'path' && k !== 'mode')
                 .sort()
@@ -1540,14 +1540,13 @@ export function jsonStringEntries(filter, column) {
         if (value === undefined)
             continue;
         if (filter.path === undefined) {
-            throw new ValidationError(`[turbine] JSON operator '${op}' on ${column} requires a \`path\` ` +
+            throw new ValidationError(`JSON operator '${op}' on ${column} requires a \`path\` ` +
                 `(e.g. { path: ['meta', 'title'], ${op}: ${valueForMessage(value)} }).`);
         }
         if (typeof value !== 'string') {
             // `typeof` rather than the value: it says everything the reader needs
             // (they passed a number where a string belongs) and carries no data.
-            throw new ValidationError(`[turbine] JSON operator '${op}' on ${column} requires a string, got ${typeof value} ` +
-                `(${valueForMessage(value)}).`);
+            throw new ValidationError(`JSON operator '${op}' on ${column} requires a string, got ${typeof value} ` + `(${valueForMessage(value)}).`);
         }
         entries.push({ op, pattern, value });
     }
@@ -1560,15 +1559,15 @@ export function jsonRangeEntries(_qi, filter, column) {
         if (value === undefined)
             continue;
         if (filter.path === undefined) {
-            throw new ValidationError(`[turbine] JSON range operator '${op}' on ${column} requires a \`path\` ` +
+            throw new ValidationError(`JSON range operator '${op}' on ${column} requires a \`path\` ` +
                 `(e.g. { path: ['meta', 'score'], ${op}: ${valueForMessage(value)} }).`);
         }
         if (typeof value !== 'number' && typeof value !== 'string') {
-            throw new ValidationError(`[turbine] JSON range operator '${op}' on ${column} requires a number or string, ` +
+            throw new ValidationError(`JSON range operator '${op}' on ${column} requires a number or string, ` +
                 `got ${typeof value} (${valueForMessage(value)}).`);
         }
         if (typeof value === 'number' && !Number.isFinite(value)) {
-            throw new ValidationError(`[turbine] JSON range operator '${op}' on ${column} requires a finite number.`);
+            throw new ValidationError(`JSON range operator '${op}' on ${column} requires a finite number.`);
         }
         entries.push({ sqlOp, value });
     }
@@ -1753,13 +1752,13 @@ export function vectorThresholdEntries(filter, field) {
         if (threshold === undefined)
             continue;
         if (typeof threshold !== 'number' || !Number.isFinite(threshold)) {
-            throw new ValidationError(`[turbine] Vector distance threshold "${cmp}" on "${field}" must be a finite number; ` +
+            throw new ValidationError(`Vector distance threshold "${cmp}" on "${field}" must be a finite number; ` +
                 `got ${typeof threshold} (${valueForMessage(threshold)}).`);
         }
         entries.push({ sqlOp, threshold });
     }
     if (entries.length === 0) {
-        throw new ValidationError(`[turbine] Vector distance filter on "${field}" requires at least one comparison (lt / lte / gt / gte).`);
+        throw new ValidationError(`Vector distance filter on "${field}" requires at least one comparison (lt / lte / gt / gte).`);
     }
     return entries;
 }
@@ -1771,7 +1770,7 @@ export function buildTextSearchClause(qi, column, filter, params) {
     requireFullTextSearch(qi);
     const config = filter.config ?? 'english';
     if (!validateTextSearchConfig(config)) {
-        throw new ValidationError(`[turbine] Invalid text search config "${config}": only alphanumeric characters and underscores are allowed.`);
+        throw new ValidationError(`Invalid text search config "${config}": only alphanumeric characters and underscores are allowed.`);
     }
     params.push(filter.search);
     return `to_tsvector('${config}', ${column}) @@ to_tsquery('${config}', ${qi.p(params.length)})`;

package/dist/query/writes.js

@@ -138,7 +138,7 @@ export function buildCreate(qi, args) {
                 throw new NotFoundError({
                     table: qi.table,
                     operation: 'create',
-                    message: `[turbine] create on "${qi.table}" returned no row from RETURNING *; this should never happen.`,
+                    message: `create on "${qi.table}" returned no row from RETURNING *; this should never happen.`,
                 });
             }
             return parseWriteRow(qi, row);
@@ -250,7 +250,7 @@ function assertUniformCreateManyRows(qi, rows, firstKeys) {
             parts.push(`does not supply ${quoteList(missing)}`);
         if (unexpected.length > 0)
             parts.push(`supplies ${quoteList(unexpected)}, which the first row does not`);
-        throw new ValidationError(`[turbine] createMany on "${qi.table}": row ${i} ${parts.join(' and ')}. ` +
+        throw new ValidationError(`createMany on "${qi.table}": row ${i} ${parts.join(' and ')}. ` +
             'Every row must supply the same fields: createMany builds ONE statement whose column list comes from the ' +
             "first row, so a field a later row omits would be written as NULL over that column's default, and a field " +
             'only a later row names would be dropped. Supply the field explicitly on every row (a field set to ' +
@@ -581,7 +581,7 @@ export function buildUpsert(qi, args) {
                     table: qi.table,
                     where: args.where,
                     operation: 'upsert',
-                    message: `[turbine] upsert on "${qi.table}" returned no row from RETURNING *; this should never happen.`,
+                    message: `upsert on "${qi.table}" returned no row from RETURNING *; this should never happen.`,
                 });
             }
             return parseWriteRow(qi, row);
@@ -823,7 +823,7 @@ export function parseWriteRow(qi, row) {
  */
 export function assertWritable(qi, operation) {
     if (qi.tableMeta.isView) {
-        throw new ValidationError(`[turbine] Cannot ${operation} "${qi.table}": it is a view (read-only). ` +
+        throw new ValidationError(`Cannot ${operation} "${qi.table}": it is a view (read-only). ` +
             'Views support reads (findMany/findFirst/…) but not writes.');
     }
 }
@@ -840,7 +840,7 @@ export function assertNoGeneratedColumns(qi, data, operation) {
             continue;
         const col = qi.tableMeta.columns.find((c) => c.field === key || c.name === key || c.name === camelToSnake(key));
         if (col?.isGeneratedStored) {
-            throw new ValidationError(`[turbine] Cannot ${operation} "${qi.table}": column "${key}" is a GENERATED ALWAYS AS (…) STORED ` +
+            throw new ValidationError(`Cannot ${operation} "${qi.table}": column "${key}" is a GENERATED ALWAYS AS (…) STORED ` +
                 'column whose value the database computes, remove it from your data.');
         }
     }
@@ -884,7 +884,7 @@ export function buildSetClause(qi, key, value, params) {
             }
             // Arithmetic operators: must be finite numbers
             if (typeof opValue !== 'number' || !Number.isFinite(opValue)) {
-                throw new ValidationError(`[turbine] update operator "${op}" on "${qi.table}.${key}" requires a finite number, got ${typeof opValue}`);
+                throw new ValidationError(`update operator "${op}" on "${qi.table}.${key}" requires a finite number, got ${typeof opValue}`);
             }
             if (op === 'increment') {
                 params.push(opValue);
@@ -938,7 +938,7 @@ export function assertBindableSetValue(qi, key, value) {
     const column = qi.toColumn(key);
     if (whereMod.isJsonColumnType(qi, whereMod.getColumnPgType(qi, column)))
         return;
-    throw new ValidationError(`[turbine] Unknown update operator "${keys[0]}" on "${qi.table}.${key}". ` +
+    throw new ValidationError(`Unknown update operator "${keys[0]}" on "${qi.table}.${key}". ` +
         `Supported: ${[...UPDATE_OPERATOR_KEYS].join(', ')}. ` +
         'A plain object is only written as a value on a json/jsonb column.');
 }

package/dist/realtime.js

@@ -48,13 +48,13 @@ const MAX_CHANNEL_LEN = 63;
  */
 export function validateChannel(channel) {
     if (typeof channel !== 'string' || channel.length === 0) {
-        throw new ValidationError('[turbine] $listen/$notify channel must be a non-empty string');
+        throw new ValidationError('$listen/$notify channel must be a non-empty string');
     }
     if (channel.length > MAX_CHANNEL_LEN) {
-        throw new ValidationError(`[turbine] $listen/$notify channel "${channel}" exceeds the ${MAX_CHANNEL_LEN}-character Postgres identifier limit`);
+        throw new ValidationError(`$listen/$notify channel "${channel}" exceeds the ${MAX_CHANNEL_LEN}-character Postgres identifier limit`);
     }
     if (!CHANNEL_REGEX.test(channel)) {
-        throw new ValidationError(`[turbine] Invalid $listen/$notify channel "${channel}", must match /^[A-Za-z_][A-Za-z0-9_]*$/ ` +
+        throw new ValidationError(`Invalid $listen/$notify channel "${channel}", must match /^[A-Za-z_][A-Za-z0-9_]*$/ ` +
             '(letters, digits, underscores; cannot start with a digit)');
     }
 }
@@ -82,7 +82,7 @@ export async function createSubscription(pool, channel, quotedChannel, handler,
     // give the connection straight back.
     if (typeof client.on !== 'function') {
         client.release?.();
-        throw new ConnectionError('[turbine] $listen requires a persistent connection that can push notifications. ' +
+        throw new ConnectionError('$listen requires a persistent connection that can push notifications. ' +
             'The configured pool returned a client with no event support (stateless HTTP drivers ' +
             'like Neon HTTP / Vercel Postgres cannot LISTEN). Use a TCP pg.Pool for LISTEN/NOTIFY.');
     }

package/dist/schema-metadata.js

@@ -130,7 +130,7 @@ function mapIndexes(tableDef, declared) {
             // index instead of emitting malformed PowQL later.
             for (const seg of idx.path) {
                 if (typeof seg === 'number' && (!Number.isInteger(seg) || seg < 0)) {
-                    throw new ValidationError(`[turbine] Doc-field index "${name}" on "${tableDef.name}": array-index path segment ${seg} must be a ` +
+                    throw new ValidationError(`Doc-field index "${name}" on "${tableDef.name}": array-index path segment ${seg} must be a ` +
                         'non-negative integer (a JSON array index). Use a string for an object key.');
                 }
             }

package/dist/schema-sql.js

@@ -71,7 +71,7 @@ function resolveDdlType(config, dialect, columnName) {
         const dims = config.vectorDimensions;
         // pgvector caps a `vector` column at 16000 dimensions.
         if (typeof dims !== 'number' || !Number.isInteger(dims) || dims < 1 || dims > 16000) {
-            throw new ValidationError(`[turbine] Column "${columnName}": vector dimensions must be an integer between 1 and 16000, got ${String(dims)}.`);
+            throw new ValidationError(`Column "${columnName}": vector dimensions must be an integer between 1 and 16000, got ${String(dims)}.`);
         }
         base = `vector(${dims})`;
     }
@@ -1526,7 +1526,7 @@ async function pinSearchPath(client, pgSchema) {
         pgSchema,
     ]);
     if (!present.rows[0]?.present) {
-        throw new ValidationError(`[turbine] Schema "${pgSchema}" does not exist in this database. ` +
+        throw new ValidationError(`Schema "${pgSchema}" does not exist in this database. ` +
             `Postgres accepts a missing namespace in search_path without complaint, so pushing anyway would ` +
             `create every table in whichever schema resolves next (usually public) and report success. ` +
             `Create the schema first (CREATE SCHEMA "${pgSchema}") or correct the configured schema name.`);
@@ -1542,7 +1542,7 @@ async function pinSearchPath(client, pgSchema) {
 }
 /** Format the destructive-push refusal message (mirrors the migrate gate copy). */
 function formatDestructivePushError(hits) {
-    const lines = ['[turbine] Refusing to apply schema changes containing DESTRUCTIVE statements:', ''];
+    const lines = ['Refusing to apply schema changes containing DESTRUCTIVE statements:', ''];
     for (const h of hits) {
         lines.push(`  - [${h.kind}] ${h.target}: ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
     }

package/dist/seed.js

@@ -128,7 +128,7 @@ function markSeedRan() {
 async function runSeed(fn) {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) {
-        throw new ConnectionError('[turbine] DATABASE_URL is required to run this seed.');
+        throw new ConnectionError('DATABASE_URL is required to run this seed.');
     }
     const db = new TurbineClient({ connectionString }, emptySchema);
     try {

package/dist/sqlite.js

@@ -108,11 +108,11 @@ function loadDatabaseSync() {
         ctor = req('node:sqlite').DatabaseSync;
     }
     catch (err) {
-        throw new ConnectionError("[turbine] turbine-orm/sqlite requires Node's built-in 'node:sqlite' module (Node >= 22.5). " +
+        throw new ConnectionError("turbine-orm/sqlite requires Node's built-in 'node:sqlite' module (Node >= 22.5). " +
             `Upgrade Node to >= 22.5, or pass an already-open better-sqlite3-compatible handle. (${err.message})`);
     }
     if (typeof ctor !== 'function') {
-        throw new ConnectionError("[turbine] 'node:sqlite' loaded but did not export a DatabaseSync constructor, this Node build may lack SQLite support.");
+        throw new ConnectionError("'node:sqlite' loaded but did not export a DatabaseSync constructor, this Node build may lack SQLite support.");
     }
     cachedDatabaseSync = ctor;
     return cachedDatabaseSync;
@@ -363,17 +363,17 @@ function augmentSqliteError(err) {
 function sqliteLogicError(message, cause) {
     const missingTable = /^no such table:\s*(\S+)/i.exec(message);
     if (missingTable) {
-        return new ValidationError(`[turbine] SQLite has no table "${missingTable[1]}": ${message}. ` +
+        return new ValidationError(`SQLite has no table "${missingTable[1]}": ${message}. ` +
             'Create it first (run your migrations, or execute the CREATE TABLE statements for this schema); ' +
             'an in-memory database starts empty on every connection.', { cause });
     }
     const missingColumn = /^no such column:\s*(\S+)/i.exec(message);
     if (missingColumn) {
-        return new ValidationError(`[turbine] SQLite has no column "${missingColumn[1]}": ${message}. ` +
+        return new ValidationError(`SQLite has no column "${missingColumn[1]}": ${message}. ` +
             'Check the spelling against the table as it exists in this database, ' +
             'and re-run `turbine generate` if the schema has changed.', { cause });
     }
-    return new ValidationError(`[turbine] SQLite rejected the statement: ${message}`, { cause });
+    return new ValidationError(`SQLite rejected the statement: ${message}`, { cause });
 }
 function normalizeQueryArgs(arg, values) {
     if (typeof arg === 'string')
@@ -987,7 +987,7 @@ export async function introspectSqlite(options) {
         db = new DatabaseSync(options.connectionString);
     }
     catch (err) {
-        throw new ConnectionError(`[turbine] Failed to open SQLite database "${options.connectionString}": ${err.message}`);
+        throw new ConnectionError(`Failed to open SQLite database "${options.connectionString}": ${err.message}`);
     }
     try {
         return introspectSqliteDatabase(db, { include: options.include, exclude: options.exclude });
@@ -1003,7 +1003,7 @@ function openSqliteDatabase(target, options) {
         db = new DatabaseSync(target);
     }
     catch (err) {
-        throw new ConnectionError(`[turbine] Failed to open SQLite database "${target}": ${err.message}`);
+        throw new ConnectionError(`Failed to open SQLite database "${target}": ${err.message}`);
     }
     db.exec(`PRAGMA busy_timeout = ${Number(options.busyTimeoutMs ?? 5000)}`);
     if (options.foreignKeys !== false)

package/dist/typed-sql.js

@@ -66,7 +66,7 @@ export function buildTypedSql(strings, values, dialect = postgresDialect) {
     // silently desync placeholders from params (pg would reject it, but fail
     // loudly here instead).
     if (strings.length !== values.length + 1) {
-        throw new ValidationError(`[turbine] sql template segment/value count mismatch: ${strings.length} segments, ${values.length} values.`);
+        throw new ValidationError(`sql template segment/value count mismatch: ${strings.length} segments, ${values.length} values.`);
     }
     let sql = '';
     for (let i = 0; i < strings.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.76.0",
+  "version": "0.77.0",
   "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).",
@@ -125,10 +125,14 @@
     "test:unit": "DATABASE_URL= tsx --test src/test/*.test.ts",
     "//test:coverage": "Collection and reporting are SEPARATE, and the report is not c8's. c8 merges every process's V8 coverage into one ProcessCov before converting to istanbul, and that merge is not monotonic on a run this size: measured on this suite, query/relations.ts read 3043 covered lines at 240 process files and 1333 at 359, and a 448-test SUBSET read 91.88% where the full 5,819-test superset read 41.78%. scripts/coverage-report.mjs keeps every other c8 behaviour (same .c8rc.json, same reporters, same checkCoverages gate) and only moves the merge to the istanbul level, where it is additive and cannot go backwards. Collection is a bare NODE_V8_COVERAGE, which is exactly what the c8 wrapper set; dropping the wrapper also drops the broken merge from the critical path instead of running it and discarding the result.",
     "test:coverage": "rm -rf coverage/tmp && mkdir -p coverage/tmp && NODE_V8_COVERAGE=coverage/tmp tsx --test --test-concurrency=1 src/test/*.test.ts && node scripts/coverage-report.mjs",
+    "//coverage:codegen": "The ratchet for the two code-generation modules, which .c8rc.json excludes from the main gate and which therefore sat in no gate at all. introspect.ts carries a stated correctness invariant (determinism) and generate.ts writes executable TypeScript from database-controlled identifiers, which is the highest-consequence untested code in the package. Both were excluded from all measurement. Same ratchet argument. Adds NO test execution: it re-reports the coverage `npm run test:coverage` already wrote to coverage/tmp, under .c8rc.codegen.json, so it must run AFTER that command. It goes through scripts/coverage-report.mjs rather than `c8 report` because the main collection is 418 process files, past the point where c8's own merge stops being monotonic (see //merge-bug in .c8rc.json). Floors, thresholds and the per-file reasoning live in .c8rc.codegen.json.",
+    "coverage:codegen": "node scripts/coverage-report.mjs --config .c8rc.codegen.json",
+    "//check:coverage-sync": "The three-way coupling between a coverage collection and the floors that hold it. A file can be added to coverage:cli:collect and then be held by NOTHING, which is not a missing gate but a slower lane enforcing a floor of zero, and it has happened twice (mcp.ts and error-catalog.ts each spent a release that way). The invariant is that every file in the collection is named by a per-file gate OR by the aggregate, NOT that the collection and the aggregate are equal: cli/index.ts is deliberately outside the aggregate, see //coverage:cli:gate:aggregate. It also refuses a gate that names a file nobody collects, which measures nothing and passes, and it fails closed on an empty parse. It runs FIRST in test:coverage:cli, ahead of the collection, because it needs no coverage data and its failure names the missing wiring instead of a number.",
+    "check:coverage-sync": "node scripts/check-coverage-gate-sync.mjs",
     "//coverage:cli": "The CLI coverage gate, split into ONE collection run plus a per-file threshold check for every file in it, and an aggregate. c8 enforces a single threshold set per invocation and its --per-file applies the SAME numbers to every file, neither of which can express 'destructive.ts holds 100 while migrate.ts holds 70'. An aggregate-only floor lets the least-covered file spend the whole slack the best-covered file earned: at the measured 3623/2951 lines, migrate.ts could fall from 70.3% to 66.6% with the aggregate still green. So each file gets its OWN floor, checked by re-reporting the coverage already on disk (c8 report re-reads ./coverage/tmp, so this costs no extra test run). The aggregate check is kept as well: it catches all three sagging together inside their individual margins. Per-file gates run FIRST because their failure names the file. DATABASE_URL is neutralized on the collection run: these test files include live migration tests that create and drop tables, and this script runs from prepublishOnly.",
-    "test:coverage:cli": "npm run coverage:cli:collect && npm run coverage:cli:gate:destructive && npm run coverage:cli:gate:sql-statements && npm run coverage:cli:gate:pii-guard && npm run coverage:cli:gate:error-catalog && npm run coverage:cli:gate:mcp && npm run coverage:cli:gate:compile-query && npm run coverage:cli:gate:studio && npm run coverage:cli:gate:migrate && npm run coverage:cli:gate:aggregate",
+    "test:coverage:cli": "npm run check:coverage-sync && npm run coverage:cli:collect && npm run coverage:cli:gate:destructive && npm run coverage:cli:gate:sql-statements && npm run coverage:cli:gate:pii-guard && npm run coverage:cli:gate:error-catalog && npm run coverage:cli:gate:mcp && npm run coverage:cli:gate:compile-query && npm run coverage:cli:gate:studio && npm run coverage:cli:gate:migrate && npm run coverage:cli:gate:index && npm run coverage:cli:gate:aggregate",
     "//coverage:cli:collect": "--check-coverage=false is load-bearing, not tidying. c8 reads .c8rc.json for defaults, so this COLLECTION step was silently enforcing the MAIN gate's global thresholds against a src/cli-only file set. That is a gate nobody wrote and nobody wanted, and it went unnoticed only because the main floor was low enough (75) for the CLI aggregate (89.29) to clear it by accident. When the main floors were re-baselined to 93/89/78 (see //merge-bug in .c8rc.json) it started failing here, several steps before the per-file gates that are supposed to decide. Thresholds for these files belong to the coverage:cli:gate:* scripts, which pass their own explicitly.",
-    "coverage:cli:collect": "DATABASE_URL= c8 --all --check-coverage=false --reporter text --exclude 'src/test/**' --include src/cli/studio.ts --include src/cli/migrate.ts --include src/cli/destructive.ts --include src/cli/sql-statements.ts --include src/cli/pii-predicate-guard.ts --include src/cli/mcp.ts --include src/cli/compile-query.ts --include src/cli/error-catalog.ts tsx --test src/test/studio-write.test.ts src/test/pii-guard-symmetry.test.ts src/test/studio-demo.test.ts src/test/studio.test.ts src/test/studio-security.test.ts src/test/migrate.test.ts src/test/migrate-deploy.test.ts src/test/migrate-smoke-fixes.test.ts src/test/tracking-table-race.test.ts src/test/destructive-dynamic-assembly.test.ts src/test/destructive-migrations.test.ts src/test/backfill-recipe.test.ts src/test/cli.test.ts src/test/cli-diff-migration.test.ts src/test/cli-flags.test.ts src/test/cli-first-run.test.ts src/test/mcp.test.ts src/test/mcp-relations.test.ts src/test/mcp-pii.test.ts src/test/mcp-pii-round2.test.ts src/test/mcp-agent-tools.test.ts src/test/mcp-compile-query.test.ts src/test/mcp-perimeter-bounds.test.ts",
+    "coverage:cli:collect": "DATABASE_URL= c8 --all --check-coverage=false --reporter text --exclude 'src/test/**' --include src/cli/studio.ts --include src/cli/migrate.ts --include src/cli/destructive.ts --include src/cli/sql-statements.ts --include src/cli/pii-predicate-guard.ts --include src/cli/mcp.ts --include src/cli/compile-query.ts --include src/cli/error-catalog.ts --include src/cli/index.ts tsx --test src/test/studio-write.test.ts src/test/pii-guard-symmetry.test.ts src/test/studio-demo.test.ts src/test/studio.test.ts src/test/studio-security.test.ts src/test/migrate.test.ts src/test/migrate-deploy.test.ts src/test/migrate-smoke-fixes.test.ts src/test/tracking-table-race.test.ts src/test/destructive-dynamic-assembly.test.ts src/test/destructive-migrations.test.ts src/test/backfill-recipe.test.ts src/test/cli.test.ts src/test/cli-diff-migration.test.ts src/test/cli-flags.test.ts src/test/cli-first-run.test.ts src/test/mcp.test.ts src/test/mcp-relations.test.ts src/test/mcp-pii.test.ts src/test/mcp-pii-round2.test.ts src/test/mcp-agent-tools.test.ts src/test/mcp-compile-query.test.ts src/test/mcp-perimeter-bounds.test.ts",
     "coverage:cli:gate": "c8 report --all --exclude 'src/test/**' --reporter text --check-coverage",
     "coverage:cli:gate:destructive": "npm run coverage:cli:gate -- --include src/cli/destructive.ts --lines 98 --statements 98 --branches 84 --functions 98",
     "coverage:cli:gate:sql-statements": "npm run coverage:cli:gate -- --include src/cli/sql-statements.ts --lines 100 --statements 100 --branches 98 --functions 100",
@@ -138,26 +142,30 @@
     "//coverage:cli:gate:compile-query": "compile_query's core: the CLOSED set of read operations an agent may compile, the sealed pool that makes 'never executes' structural rather than promised, and the aggregate-arg name harvest the PII refusal runs on. Every one of those is a refusal boundary, which is the same reason destructive.ts and pii-predicate-guard.ts carry their own floors. It gets a gate the SAME commit it joins coverage:cli:collect and the aggregate --include list, because a file in the collection with neither is collected and enforced by nothing, which is how mcp.ts and error-catalog.ts spent a release at a floor of zero. Floors measured 2026-08-15 at 100 lines / 100 statements / 94.21 branches / 100 functions.",
     "coverage:cli:gate:compile-query": "npm run coverage:cli:gate -- --include src/cli/compile-query.ts --lines 100 --statements 100 --branches 94 --functions 100",
     "coverage:cli:gate:error-catalog": "npm run coverage:cli:gate -- --include src/cli/error-catalog.ts --lines 100 --statements 100 --branches 90 --functions 100",
+    "//coverage:cli:gate:index": "cli/index.ts is the largest file in the repo (5,945 lines) and was in no coverage gate at all. The .c8rc.json //cli-gate argument for the other CLI files applies verbatim: coverage could fall to zero without anything noticing. The floors are LOW on purpose and are not a target: this file is argument parsing and command dispatch whose `process.exit` paths dominate any figure set over it, and the point of the gate is that the number cannot fall silently, not that it is high. MEASURED 2026-08-23 by `npm run coverage:cli:collect` (no database), read from the json-summary reporter rather than the text table, per the //cli-gate-measurements note: 32.62 lines / 32.62 statements / 75.62 branches / 20 functions, identical in isolation and in the nine-file collection. Floors sit about two points under. Raise as coverage improves; never lower one without recording why. It is deliberately NOT in coverage:cli:gate:aggregate, see that key's note.",
+    "coverage:cli:gate:index": "npm run coverage:cli:gate -- --include src/cli/index.ts --lines 30 --statements 30 --branches 73 --functions 18",
     "coverage:cli:gate:studio": "npm run coverage:cli:gate -- --include src/cli/studio.ts --lines 82 --statements 82 --branches 81 --functions 86",
     "coverage:cli:gate:migrate": "npm run coverage:cli:gate -- --include src/cli/migrate.ts --lines 69 --statements 69 --branches 91 --functions 73",
-    "//coverage:cli:gate:aggregate": "Re-baselined 2026-08-15 when compile-query.ts joined the --include list: measured 89.28 lines / 89.28 statements / 86.77 branches / 89.18 functions, up from a 87/87/85/86 floor set over seven files (itself up from 78/78/84/82 over five). Raise as coverage improves, never lower one without recording why.",
+    "//coverage:cli:gate:aggregate": "Re-baselined 2026-08-15 when compile-query.ts joined the --include list: measured 89.28 lines / 89.28 statements / 86.77 branches / 89.18 functions, up from a 87/87/85/86 floor set over seven files (itself up from 78/78/84/82 over five). Raise as coverage improves, never lower one without recording why. WHY cli/index.ts IS NOT HERE, although it is in coverage:cli:collect and has its own per-file gate: it is 5,945 lines at 32.62%, so folding it in drops this aggregate from a measured 89.63 lines / 87.15 branches / 89.18 functions to 66.32 / 85.76 / 63.38, which would mean LOWERING two floors by about 25 points. That is the rule above broken, and it also empties the aggregate of its purpose. This check exists only as the backstop that catches every file sagging together inside its individual margin; with one 5,945-line file at 32% dominating the denominator, the other eight could collectively shed well over a thousand covered lines with this still green. The invariant the collection actually needs is that every collected file is held by SOME floor, and index.ts is held by coverage:cli:gate:index. That is what check:coverage-sync asserts.",
     "coverage:cli:gate:aggregate": "npm run coverage:cli:gate -- --include src/cli/studio.ts --include src/cli/migrate.ts --include src/cli/destructive.ts --include src/cli/sql-statements.ts --include src/cli/pii-predicate-guard.ts --include src/cli/mcp.ts --include src/cli/compile-query.ts --include src/cli/error-catalog.ts --lines 89 --statements 89 --branches 86 --functions 89",
     "//lint": "`--error-on-warnings` is load-bearing, not cosmetic. Biome exits 0 on a warning, so `npm run lint` passed while reporting an unused import, and both the lint CI job and prepublishOnly read only the exit code. Every rule this repo runs is one it means, so a warning nobody has to act on is a rule that should not be enabled.",
     "lint": "biome check --error-on-warnings src/",
     "lint:fix": "biome check --write src/",
     "format": "biome format --write src/",
     "check:error-codes": "tsx scripts/check-error-codes.ts",
+    "//check:error-prefix": "No message reaching a TurbineError may hand-write a `[turbine] ` prefix. formatErrorMessage prepends `[TURBINE_EXXX] ` unless the message already opens with that exact tag, and a hand-written `[turbine] ` never matches one, so the two stacked on roughly 355 of the package's throw sites. A prefix rule looks unnecessary because formatErrorMessage guarantees the [CODE] tag: true, and not the failure mode, which is the INTERACTION between the automatic tag and a manual one. Diagnostics that no code tag ever touches (console calls, stream writes, Studio HTTP bodies) keep the prefix and are named in the script's DIAGNOSTIC_SINKS.",
+    "check:error-prefix": "node scripts/check-error-prefix.mjs",
     "check:changelog": "node scripts/check-changelog-headings.mjs",
     "check:cycles": "node scripts/check-import-cycles.mjs",
-    "//check:skip-gates": "Guards the TURBINE_REQUIRE_ENGINE coupling, which is a regex against a human-readable skipGate reason string: rewording a reason silently disarms the guard and the engine job it protects goes green over a suite that never ran. Fails on a reason no engine pattern claims and no allowlist entry excuses, on a token no CI job sets, and on a workflow token that is not a known engine.",
+    "//check:skip-gates": "Guards the TURBINE_REQUIRE_ENGINE coupling, which is a regex against a human-readable skipGate reason string: rewording a reason silently disarms the guard and the engine job it protects goes green over a suite that never ran. Fails on a reason no engine pattern claims and no allowlist entry excuses, on a token no CI job sets, and on a workflow token that is not a known engine. Since 0.76.0 it also fails on a test file that calls turbineSqlite() without first probing that node:sqlite exists, because that precondition is a Node VERSION rather than an env var: it holds on every dev machine and on three of the four unit-matrix legs, so a missing gate is invisible until CI, which is where it was found, after publish.",
     "check:skip-gates": "tsx scripts/check-skip-gate-reasons.ts",
-    "//check:private-terms": "The `--all` mode of the pre-commit private-material guard, over every TRACKED file rather than the staged diff. The hook is advisory (`git commit --no-verify` skips it) and nothing downstream re-asked, so this runs in CI's lint job. `.private-terms` is gitignored, so CI enforces the builtin provenance patterns only.",
+    "//check:private-terms": "The `--all` mode of the pre-commit private-material guard, over every TRACKED file rather than the staged diff. The hook is advisory (`git commit --no-verify` skips it) and nothing downstream re-asked, so this runs in CI's lint job. `.private-terms` is gitignored, so CI enforces the builtin provenance patterns only. It sits on BOTH publish paths as well: prepublishOnly for a local `npm publish`, and release.yml's test job for a tag push. A leak guard reachable only from the one workflow that does not gate publishing had a single bypassable enforcement point, which for a public repo is the same as none. Scope note, `--all` enumerates with `git ls-files`, so an UNTRACKED working-tree file is outside the scan by construction; that is the right boundary here, because package.json `files` publishes dist/, skills/, LICENSE and README.md, all of which are tracked or generated from tracked sources.",
     "check:private-terms": "node scripts/check-private-terms.mjs --all",
     "check:release-tests": "node scripts/check-release-tests.mjs",
     "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:changelog && npm run check:cycles && npm run check:skip-gates && npm run check:package && npm run check:package-types && npm run size && npm run check:release-tests",
+    "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",
     "prepack": "node scripts/strip-prepare.mjs",
     "postpack": "node scripts/restore-prepare.mjs",
     "size": "size-limit",