turbine-orm 0.76.0 → 0.77.0

package/dist/powql.d.ts

@@ -34,7 +34,7 @@
  *
  * @module
  */
-import { type PowdbPool } from './powdb.js';
+import type { PowdbPool } from './powdb.js';
 import type { MiddlewareFn, QueryInterfaceOptions } from './query/index.js';
 import type { AggregateArgs, AggregateResult, CountArgs, CreateArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FindManyArgs, FindUniqueArgs, GroupByArgs, UpdateArgs, UpdateManyArgs, UpsertArgs } from './query/types.js';
 import { type SchemaMetadata } from './schema.js';

package/dist/powql.js

@@ -37,7 +37,7 @@
 import { randomUUID } from 'node:crypto';
 import { NotFoundError, OptimisticLockError, ReadOnlyError, TimeoutError, UnsupportedFeatureError, ValidationError, } from './errors.js';
 import { executeNestedCreate, executeNestedUpdate, hasRelationFields, } from './nested-write.js';
-import { ALL_POWDB_CAPABILITIES, coerceNativeValue, isJsonColumn, isPowdbDatetimeColumn, isStaleFramePowdbError, PowdbFloatParam, PowdbJsonParam, powqlColumnType, quotePowqlDotted, quotePowqlIdent, requireCapability, rowToEntity, } from './powdb.js';
+import { ALL_POWDB_CAPABILITIES, baseTsType, coerceNativeValue, isJsonColumn, isPowdbDatetimeColumn, isStaleFramePowdbError, PowdbFloatParam, PowdbJsonParam, powqlColumnType, quotePowqlDotted, quotePowqlIdent, requireCapability, rowToEntity, } from './powdb-shared.js';
 import { assertAggregatePiiOptIn } from './query/aggregates.js';
 import { assertWhereIdentifiesOneRow, expandCompoundUniqueWhere } from './query/compound-unique.js';
 import { ARRAY_OPERATOR_KEYS, isJsonFilter, isRelationPickOrderBy, orderByEntries } from './query/filters.js';
@@ -189,7 +189,7 @@ export class PowqlInterface {
         this.options = options;
         const meta = schema.tables[table];
         if (!meta) {
-            throw new ValidationError(`[turbine] Unknown table "${table}". ${availableClause(Object.keys(schema.tables), 'The schema has no tables.')}`);
+            throw new ValidationError(`Unknown table "${table}". ${availableClause(Object.keys(schema.tables), 'The schema has no tables.')}`);
         }
         this.meta = meta;
         this.defaultLimit = options.defaultLimit;
@@ -222,7 +222,7 @@ export class PowqlInterface {
         const snake = resolved ?? ownLookup(this.meta.columnMap, field) ?? field;
         const col = this.meta.columns.find((c) => c.name === snake || c.field === field);
         if (!col) {
-            throw new ValidationError(`[turbine] Unknown column "${field}" on table "${this.table}". Known: ${this.meta.columns
+            throw new ValidationError(`Unknown column "${field}" on table "${this.table}". Known: ${this.meta.columns
                 .map((c) => c.field)
                 .join(', ')}`);
         }
@@ -326,7 +326,7 @@ export class PowqlInterface {
      */
     writeRef(value, col, params) {
         if (typeof value === 'number' && !Number.isFinite(value) && this.isFloatCol(col)) {
-            throw new ValidationError(`[turbine] Non-finite value for float column "${col.name}" on "${this.table}".`);
+            throw new ValidationError(`Non-finite value for float column "${col.name}" on "${this.table}".`);
         }
         return this.param(value, params, col);
     }
@@ -452,7 +452,7 @@ export class PowqlInterface {
             ['offset', offset],
         ]) {
             if (value !== undefined && value !== null && value < 0) {
-                throw new ValidationError(`[turbine] ${context} on "${this.table}": \`${name}\` must not be negative (got ${value}).`);
+                throw new ValidationError(`${context} on "${this.table}": \`${name}\` must not be negative (got ${value}).`);
             }
         }
     }
@@ -502,7 +502,7 @@ export class PowqlInterface {
                 // Relation filters are pre-resolved to scalar in/notIn by
                 // resolveRelationFilters() before buildWhere runs, reaching here means
                 // a caller skipped that step (an internal bug, not user error).
-                throw new ValidationError(`[turbine] internal: relation filter "${key}" reached buildWhere unresolved (missing resolveRelationFilters()).`);
+                throw new ValidationError(`internal: relation filter "${key}" reached buildWhere unresolved (missing resolveRelationFilters()).`);
             }
             else {
                 // A JsonFilter (or a bare `{ path }`) can compile to zero clauses; skip
@@ -632,7 +632,7 @@ export class PowqlInterface {
                     conds.push(`${lhs} like ${this.bindLike(`%${escapeLike(String(opVal))}`, params, insensitive)}`);
                     break;
                 default:
-                    throw new ValidationError(`[turbine] Unsupported operator "${opName}" on PowDB.`);
+                    throw new ValidationError(`Unsupported operator "${opName}" on PowDB.`);
             }
         }
         return conds.length > 1 ? `(${conds.join(' and ')})` : (conds[0] ?? this.alwaysFalse());
@@ -720,14 +720,14 @@ export class PowqlInterface {
             if (v === undefined)
                 continue;
             if (filter.path === undefined) {
-                throw new ValidationError(`[turbine] JSON range operator '${op}' on ${col.name} requires a \`path\` ` +
+                throw new ValidationError(`JSON range operator '${op}' on ${col.name} requires a \`path\` ` +
                     `(e.g. { path: ['meta', 'score'], ${op}: ${JSON.stringify(v)} }).`);
             }
             if (typeof v !== 'number' && typeof v !== 'string') {
-                throw new ValidationError(`[turbine] JSON range operator '${op}' on ${col.name} requires a number or string, got ${JSON.stringify(v)}.`);
+                throw new ValidationError(`JSON range operator '${op}' on ${col.name} requires a number or string, got ${JSON.stringify(v)}.`);
             }
             if (typeof v === 'number' && !Number.isFinite(v)) {
-                throw new ValidationError(`[turbine] JSON range operator '${op}' on ${col.name} requires a finite number.`);
+                throw new ValidationError(`JSON range operator '${op}' on ${col.name} requires a finite number.`);
             }
             conds.push(`${pathP()} ${powOp} ${this.param(v, params)}`);
         }
@@ -743,7 +743,7 @@ export class PowqlInterface {
         // generator bug rather than a user error, and must not silently widen the
         // query the way it used to.
         if (!conds.length) {
-            throw new ValidationError(`[turbine] internal: JSON filter on "${col.name}" compiled to no condition. This is a bug in turbine-orm.`);
+            throw new ValidationError(`internal: JSON filter on "${col.name}" compiled to no condition. This is a bug in turbine-orm.`);
         }
         return conds.length > 1 ? `(${conds.join(' and ')})` : conds[0];
     }
@@ -909,7 +909,7 @@ export class PowqlInterface {
         }
         const targetMeta = this.schema.tables[rel.to];
         if (!targetMeta)
-            throw new ValidationError(`[turbine] Relation "${rel.name}" targets unknown table "${rel.to}".`);
+            throw new ValidationError(`Relation "${rel.name}" targets unknown table "${rel.to}".`);
         // hasMany/hasOne: localKey = our referenceKey, collect the child's foreignKey.
         // belongsTo:      localKey = our foreignKey,   collect the target's referenceKey.
         const localCol = rel.type === 'belongsTo' ? fk[0] : rk[0];
@@ -938,13 +938,13 @@ export class PowqlInterface {
     async resolveManyToManyCondition(rel, mode, innerWhere, innerEmpty, timeout) {
         const through = rel.through;
         if (!through)
-            throw new ValidationError(`[turbine] manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
+            throw new ValidationError(`manyToMany relation "${rel.name}" is missing its junction (\`through\`).`);
         const sourceJ = normalizeKeyColumns(through.sourceKey);
         const targetJ = normalizeKeyColumns(through.targetKey);
         const sourceRef = normalizeKeyColumns(rel.referenceKey);
         const targetMeta = this.schema.tables[rel.to];
         if (!targetMeta)
-            throw new ValidationError(`[turbine] Relation "${rel.name}" targets unknown table "${rel.to}".`);
+            throw new ValidationError(`Relation "${rel.name}" targets unknown table "${rel.to}".`);
         if (sourceJ.length > 1 || targetJ.length > 1 || sourceRef.length > 1 || targetMeta.primaryKey.length > 1) {
             throw new UnsupportedFeatureError('composite-key manyToMany filters', 'PowDB', `relation "${rel.name}", PowQL has no tuple-\`in\` for composite junction/target keys`);
         }
@@ -1282,9 +1282,9 @@ export class PowqlInterface {
     }
     /** Build the E018 refusal for a write / `begin` on a read-only pool. */
     readOnlyError(operation) {
-        // Pass a clean detail: the ReadOnlyError constructor owns both the
-        // `[turbine] ` prefix and the "Route writes to a writable primary." hint,
-        // so adding either here would double them.
+        // Pass a clean detail: the ReadOnlyError constructor owns the "Route writes
+        // to a writable primary." hint, so adding it here would double it. The
+        // `[TURBINE_E018]` tag is added once, later, by formatErrorMessage.
         return new ReadOnlyError(`${operation} on "${this.table}" refused: this PowDB connection is read-only.`);
     }
     /**
@@ -1651,7 +1651,7 @@ export class PowqlInterface {
      */
     async loadRelations(parents, withClause, timeout, depth = 0, parent, includePii = false) {
         if (depth >= 10) {
-            throw new ValidationError(`[turbine] Nested 'with' on PowDB exceeded depth 10 (relation cycle?).`);
+            throw new ValidationError(`Nested 'with' on PowDB exceeded depth 10 (relation cycle?).`);
         }
         if (!parents.length)
             return;
@@ -1666,7 +1666,7 @@ export class PowqlInterface {
                 continue;
             const rel = this.meta.relations[relName];
             if (!rel)
-                throw new ValidationError(`[turbine] Unknown relation "${relName}" on "${this.table}".`);
+                throw new ValidationError(`Unknown relation "${relName}" on "${this.table}".`);
             if (strategyIsJoin && parent && this.joinEligible(rel, opt, parent.args, parents.length)) {
                 if (this.capabilities.serverJoins) {
                     await this.loadRelationViaJoin(parents, rel, relName, opt, parent, timeout, includePii);
@@ -1793,13 +1793,13 @@ export class PowqlInterface {
     async loadManyToMany(parents, rel, relName, opt, timeout, includePii = false) {
         const through = rel.through;
         if (!through)
-            throw new ValidationError(`[turbine] manyToMany relation "${relName}" is missing its junction (\`through\`).`);
+            throw new ValidationError(`manyToMany relation "${relName}" is missing its junction (\`through\`).`);
         const sourceJ = normalizeKeyColumns(through.sourceKey);
         const targetJ = normalizeKeyColumns(through.targetKey);
         const sourceRef = normalizeKeyColumns(rel.referenceKey);
         const targetMeta = this.schema.tables[rel.to];
         if (!targetMeta)
-            throw new ValidationError(`[turbine] Relation "${relName}" targets unknown table "${rel.to}".`);
+            throw new ValidationError(`Relation "${relName}" targets unknown table "${rel.to}".`);
         if (sourceJ.length > 1 || targetJ.length > 1 || sourceRef.length > 1 || targetMeta.primaryKey.length > 1) {
             throw new UnsupportedFeatureError('composite-key manyToMany', 'PowDB', `relation "${relName}", PowQL has no tuple-\`in\`, so composite junction/target keys can't be loaded`);
         }
@@ -2033,7 +2033,7 @@ export class PowqlInterface {
         const options = (opt === true ? {} : opt);
         const targetMeta = this.schema.tables[rel.to];
         if (!targetMeta)
-            throw new ValidationError(`[turbine] Relation "${relName}" targets unknown table "${rel.to}".`);
+            throw new ValidationError(`Relation "${relName}" targets unknown table "${rel.to}".`);
         const targetQi = new PowqlInterface(this.pool, rel.to, this.schema, [], this.options);
         const fk = normalizeKeyColumns(rel.foreignKey);
         const rk = normalizeKeyColumns(rel.referenceKey);
@@ -2073,11 +2073,11 @@ export class PowqlInterface {
     async loadManyToManyViaJoin(parents, rel, relName, opt, parent, timeout, includePii = false) {
         const through = rel.through;
         if (!through)
-            throw new ValidationError(`[turbine] manyToMany relation "${relName}" is missing its junction (\`through\`).`);
+            throw new ValidationError(`manyToMany relation "${relName}" is missing its junction (\`through\`).`);
         const options = (opt === true ? {} : opt);
         const targetMeta = this.schema.tables[rel.to];
         if (!targetMeta)
-            throw new ValidationError(`[turbine] Relation "${relName}" targets unknown table "${rel.to}".`);
+            throw new ValidationError(`Relation "${relName}" targets unknown table "${rel.to}".`);
         const targetQi = new PowqlInterface(this.pool, rel.to, this.schema, [], this.options);
         const sourceJCol = normalizeKeyColumns(through.sourceKey)[0];
         const targetJCol = normalizeKeyColumns(through.targetKey)[0];
@@ -2107,7 +2107,7 @@ export class PowqlInterface {
     joinChildCols(targetQi, options, includePii = false) {
         const plan = targetQi.projectionPlan(options.select, options.omit, includePii);
         if (plan.cols.includes('__tpk')) {
-            throw new ValidationError(`[turbine] relation target "${targetQi.table}" has a column named "__tpk", which collides with the reserved ` +
+            throw new ValidationError(`relation target "${targetQi.table}" has a column named "__tpk", which collides with the reserved ` +
                 `join correlation alias. Rename the column or load this relation with relationLoadStrategy: 'batched'.`);
         }
         return plan;
@@ -2242,7 +2242,7 @@ export class PowqlInterface {
         const { cols, forcedPk } = targetQi.projectionPlan(options.select, options.omit, includePii);
         const byName = new Map(targetQi.meta.columns.map((c) => [c.name, c]));
         for (const c of cols) {
-            const ts = (byName.get(c)?.tsType ?? '').replace(/\s*\|\s*null$/i, '').trim();
+            const ts = baseTsType(byName.get(c)?.tsType ?? '');
             if (ts === 'bigint' || ts === 'Uint8Array')
                 return null;
         }
@@ -2449,7 +2449,7 @@ export class PowqlInterface {
         // at least one projected child column is bigint/bytes. Otherwise nested
         // projections already handle it (and cache), so leave it to them.
         const hasCarrierBlockedCol = userCols.some((c) => {
-            const ts = (byName.get(c)?.tsType ?? '').replace(/\s*\|\s*null$/i, '').trim();
+            const ts = baseTsType(byName.get(c)?.tsType ?? '');
             return ts === 'bigint' || ts === 'Uint8Array';
         });
         if (!hasCarrierBlockedCol)
@@ -2633,7 +2633,7 @@ export class PowqlInterface {
                 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 "${this.table}": row ${i} ${parts.join(' and ')}. ` +
+            throw new ValidationError(`createMany on "${this.table}": row ${i} ${parts.join(' and ')}. ` +
                 'Every row must supply the same fields (a field set to `undefined` counts as omitted, exactly as it does ' +
                 'in `create`). PowQL itself would insert the ragged rows, but the SQL engines build ONE statement whose ' +
                 "column list comes from the first row, so there a later row's extra field is dropped and a field it " +
@@ -2745,14 +2745,14 @@ export class PowqlInterface {
                 else if ('divide' in opObj)
                     parts.push(`${col} := ${ref} / ${this.writeRef(opObj.divide, colMeta, params)}`);
                 else
-                    throw new ValidationError(`[turbine] Unsupported update operator on "${field}".`);
+                    throw new ValidationError(`Unsupported update operator on "${field}".`);
             }
             else {
                 parts.push(`${col} := ${this.writeRef(value, colMeta, params)}`);
             }
         }
         if (!parts.length)
-            throw new ValidationError(`[turbine] update on "${this.table}" has no fields to set.`);
+            throw new ValidationError(`update on "${this.table}" has no fields to set.`);
         return parts.join(', ');
     }
     // -------------------------------------------------------------------------
@@ -2914,7 +2914,7 @@ export class PowqlInterface {
             return { field, value: createData[field] ?? createData[pk] };
         });
         if (pkPairs.some((p) => p.value == null)) {
-            throw new ValidationError(`[turbine] upsert on "${this.table}" needs every composite-PK field in \`create\` (${pkPairs
+            throw new ValidationError(`upsert on "${this.table}" needs every composite-PK field in \`create\` (${pkPairs
                 .map((p) => p.field)
                 .join(', ')}).`);
         }
@@ -3050,7 +3050,7 @@ export class PowqlInterface {
             const usedKeys = new Set();
             const claim = (key, what) => {
                 if (key === '_count' || usedKeys.has(key)) {
-                    throw new ValidationError(`[turbine] groupBy output name "${key}" (${what}) collides with another output column on table ` +
+                    throw new ValidationError(`groupBy output name "${key}" (${what}) collides with another output column on table ` +
                         `"${this.table}": set an explicit \`alias\` (or rename the aggregate key) to disambiguate.`);
                 }
                 usedKeys.add(key);
@@ -3081,7 +3081,7 @@ export class PowqlInterface {
                 else {
                     const col = this.column(entry.field);
                     if (!isJsonColumn(col)) {
-                        throw new ValidationError(`[turbine] groupBy JSON group key on "${entry.field}" (table "${this.table}") requires a json column.`);
+                        throw new ValidationError(`groupBy JSON group key on "${entry.field}" (table "${this.table}") requires a json column.`);
                     }
                     assertAggregatePiiOptIn(this.table, this.meta, entry.field, col.name, 'groupBy JSON `by` key', resolveUnsafeFlag(args.includePii, 'includePii'));
                     this.assertJsonPath('group key', entry.field, entry.path);
@@ -3187,7 +3187,7 @@ export class PowqlInterface {
                     else {
                         const col = this.column(target.field);
                         if (!isJsonColumn(col)) {
-                            throw new ValidationError(`[turbine] groupBy ${fn} target "${key}" on "${target.field}" (table "${this.table}") requires a json column.`);
+                            throw new ValidationError(`groupBy ${fn} target "${key}" on "${target.field}" (table "${this.table}") requires a json column.`);
                         }
                         if (fn === '_min' || fn === '_max') {
                             assertAggregatePiiOptIn(this.table, this.meta, target.field, col.name, `groupBy ${fn} JSON target`, resolveUnsafeFlag(args.includePii, 'includePii'));
@@ -3195,7 +3195,7 @@ export class PowqlInterface {
                         this.assertJsonPath(`${fn} target "${key}"`, target.field, target.path);
                         const alwaysNumeric = fn === '_sum' || fn === '_avg';
                         if (alwaysNumeric && target.type === 'text') {
-                            throw new ValidationError(`[turbine] groupBy ${fn} target "${key}" on table "${this.table}": ` +
+                            throw new ValidationError(`groupBy ${fn} target "${key}" on table "${this.table}": ` +
                                 `${fn} over a JSON path is always numeric: remove \`type: 'text'\`.`);
                         }
                         const numeric = alwaysNumeric || target.type === 'numeric';
@@ -3263,7 +3263,7 @@ export class PowqlInterface {
         if (!Array.isArray(path) ||
             path.length === 0 ||
             path.some((el) => typeof el !== 'string' && !(typeof el === 'number' && Number.isFinite(el)))) {
-            throw new ValidationError(`[turbine] groupBy ${context} on "${field}" (table "${this.table}") requires a non-empty \`path\` ` +
+            throw new ValidationError(`groupBy ${context} on "${field}" (table "${this.table}") requires a non-empty \`path\` ` +
                 `array of keys/indexes (e.g. { field: '${field}', path: ['category'] }).`);
         }
     }
@@ -3315,7 +3315,7 @@ export class PowqlInterface {
                     // must come from the fixed allowlist, never from the caller's key.
                     const fn = POWQL_HAVING_AGG_FNS.get(aggKey);
                     if (!fn) {
-                        throw new ValidationError(`[turbine] Unknown aggregate "${aggKey}" in having for field "${key}" on table "${this.table}". ` +
+                        throw new ValidationError(`Unknown aggregate "${aggKey}" in having for field "${key}" on table "${this.table}". ` +
                             `Supported: ${[...POWQL_HAVING_AGG_FNS.keys()].join(', ')}.`);
                     }
                     const inner = this.lookupGroupKey(aggInner, key) ?? this.ref(key);
@@ -3353,14 +3353,14 @@ export class PowqlInterface {
                 if (key === '_count') {
                     const expr = aggOrderExprs.get('_count');
                     if (!expr) {
-                        throw new ValidationError(`[turbine] Cannot order groupBy by "_count" on table "${this.table}": _count is not selected. ` +
+                        throw new ValidationError(`Cannot order groupBy by "_count" on table "${this.table}": _count is not selected. ` +
                             `Orderable keys: ${validKeys()}.`);
                     }
                     parts.push(`${expr} ${this.groupOrderDir(value, '_count')}`);
                     continue;
                 }
                 if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-                    throw new ValidationError(`[turbine] Invalid groupBy orderBy for "${key}" on table "${this.table}": ` +
+                    throw new ValidationError(`Invalid groupBy orderBy for "${key}" on table "${this.table}": ` +
                         `expected a field map like { ${key}: { amount: 'desc' } }.`);
                 }
                 for (const [field, dirSpec] of Object.entries(value)) {
@@ -3370,7 +3370,7 @@ export class PowqlInterface {
                     // the registry is keyed by the canonical one.
                     const expr = aggOrderExprs.get(`${key}:${field}`) ?? this.aggOrderExpr(aggOrderExprs, key, field);
                     if (!expr) {
-                        throw new ValidationError(`[turbine] Cannot order groupBy by "${key}.${field}" on table "${this.table}": ` +
+                        throw new ValidationError(`Cannot order groupBy by "${key}.${field}" on table "${this.table}": ` +
                             `that aggregate is not requested in this call. Orderable keys: ${validKeys()}.`);
                     }
                     parts.push(`${expr} ${this.groupOrderDir(dirSpec, `${key}.${field}`)}`);
@@ -3379,7 +3379,7 @@ export class PowqlInterface {
             }
             const expr = this.lookupGroupKey(byOrderExprs, key);
             if (!expr) {
-                throw new ValidationError(`[turbine] Unknown field "${key}" in groupBy orderBy on table "${this.table}". Orderable keys: ${validKeys()}.`);
+                throw new ValidationError(`Unknown field "${key}" in groupBy orderBy on table "${this.table}". Orderable keys: ${validKeys()}.`);
             }
             parts.push(`${expr} ${this.groupOrderDir(value, key)}`);
         }
@@ -3469,14 +3469,14 @@ export class PowqlInterface {
             return;
         if (compiledWhere.length > 0)
             return;
-        throw new ValidationError(`[turbine] ${action} on "${this.table}" refused: the \`where\` clause is empty. ` +
+        throw new ValidationError(`${action} on "${this.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.');
     }
 }
 /** Coerce a group-key scalar string by the column's TS type (numbers/bools). */
 function coerceScalar(raw, tsType) {
-    const ts = tsType.replace(/\s*\|\s*null$/i, '').trim();
+    const ts = baseTsType(tsType);
     if (raw === 'null')
         return null;
     if (ts === 'number' || ts === 'bigint') {

package/dist/prisma-compat.js

@@ -324,7 +324,7 @@ function assertTranslateDepth(depth, clause) {
     // The two clauses core also walks raise core's own error, verbatim.
     if (clause === 'where' || clause === 'having')
         assertWhereDepth(depth, clause);
-    throw new ValidationError(`[turbine] \`${clause}\` nests more than ${MAX_WHERE_DEPTH} levels deep. That is far past anything a real ` +
+    throw new ValidationError(`\`${clause}\` nests more than ${MAX_WHERE_DEPTH} levels deep. That is far past anything a real ` +
         `query needs, and an unbounded walk over caller-supplied nesting is a stack-overflow surface, so it is ` +
         `refused. If this is a generated argument, flatten it: a single array of N entries is one level, not N.`);
 }
@@ -715,7 +715,7 @@ function translateOmit(ctx, mm, omit) {
         if (val === false || val == null)
             continue;
         if (mm.relations[key]) {
-            throw new ValidationError(`[turbine] prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
+            throw new ValidationError(`prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
                 'is a relation. Leave the relation out of `include` instead.');
         }
         out[renameField(mm, key)] = true;
@@ -741,10 +741,10 @@ function translateProjection(ctx, mm, args, depth = 0) {
     const select = args.select;
     const omitArg = args.omit;
     if (include && select) {
-        throw new ValidationError('[turbine] prisma-compat: `include` and `select` are mutually exclusive.');
+        throw new ValidationError('prisma-compat: `include` and `select` are mutually exclusive.');
     }
     if (select && omitArg) {
-        throw new ValidationError('[turbine] prisma-compat: `select` and `omit` are mutually exclusive. ' +
+        throw new ValidationError('prisma-compat: `select` and `omit` are mutually exclusive. ' +
             'A `select` already lists exactly the fields you want.');
     }
     const omit = omitArg ? translateOmit(ctx, mm, omitArg) : undefined;
@@ -761,7 +761,7 @@ function translateProjection(ctx, mm, args, depth = 0) {
             }
             const rel = mm.relations[key];
             if (!rel) {
-                throw new ValidationError(`[turbine] prisma-compat: unknown relation "${key}" in include on model "${modelName(ctx, mm)}".`);
+                throw new ValidationError(`prisma-compat: unknown relation "${key}" in include on model "${modelName(ctx, mm)}".`);
             }
             withClause[rel.name] = translateWithOption(ctx, mm, rel.name, val, depth + 1);
             hasWith = true;
@@ -816,7 +816,7 @@ function assertWriteProjectionField(ctx, mm, op, clause, key) {
         return;
     const known = Object.keys(mm.fields);
     const suggestion = suggestKey(key, new Set(known));
-    throw new ValidationError(`[turbine] prisma-compat: unknown field "${key}" in \`${clause}\` on ${modelName(ctx, mm)}.${op}().` +
+    throw new ValidationError(`prisma-compat: unknown field "${key}" in \`${clause}\` on ${modelName(ctx, mm)}.${op}().` +
         (suggestion ? ` Did you mean "${suggestion}"?` : '') +
         ` Known fields: ${known.join(', ') || '(none)'}.`);
 }
@@ -848,10 +848,10 @@ function resolveWriteProjection(ctx, mm, op, args) {
     const select = args.select;
     const omitArg = args.omit;
     if (include && select) {
-        throw new ValidationError('[turbine] prisma-compat: `include` and `select` are mutually exclusive.');
+        throw new ValidationError('prisma-compat: `include` and `select` are mutually exclusive.');
     }
     if (select && omitArg) {
-        throw new ValidationError('[turbine] prisma-compat: `select` and `omit` are mutually exclusive. ' +
+        throw new ValidationError('prisma-compat: `select` and `omit` are mutually exclusive. ' +
             'A `select` already lists exactly the fields you want.');
     }
     if (include) {
@@ -885,7 +885,7 @@ function resolveWriteProjection(ctx, mm, op, args) {
             if (val === false || val == null)
                 continue;
             if (mm.relations[key]) {
-                throw new ValidationError(`[turbine] prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
+                throw new ValidationError(`prisma-compat: \`omit\` on model "${modelName(ctx, mm)}" takes scalar fields, but "${key}" ` +
                     'is a relation.');
             }
             assertWriteProjectionField(ctx, mm, op, 'omit', key);
@@ -1768,7 +1768,7 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
     };
     const requireWhere = (args, op) => {
         if (!args || args.where === undefined) {
-            throw new ValidationError(`[turbine] prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
+            throw new ValidationError(`prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
         }
         return args;
     };
@@ -1934,7 +1934,7 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
 function poolOf(db) {
     const pool = db.pool;
     if (!pool)
-        throw new ValidationError('[turbine] prisma-compat: raw SQL needs a TurbineClient with an active pool.');
+        throw new ValidationError('prisma-compat: raw SQL needs a TurbineClient with an active pool.');
     return pool;
 }
 function placeholderOf(db) {
@@ -2127,7 +2127,7 @@ const EMPTY_EXTENSIONS = { client: {}, model: new Map(), allModels: {} };
  */
 function applyExtension(prev, ext, modelKeys, clientKeys) {
     if (typeof ext !== 'object' || ext === null) {
-        throw new ValidationError('[turbine] prisma-compat: $extends expects an extension object or a function ' +
+        throw new ValidationError('prisma-compat: $extends expects an extension object or a function ' +
             `(Prisma.defineExtension callback form), received ${ext === null ? 'null' : typeof ext}.`);
     }
     for (const [component, value] of Object.entries(ext)) {
@@ -2145,7 +2145,7 @@ function applyExtension(prev, ext, modelKeys, clientKeys) {
     const client = { ...prev.client };
     for (const [name, member] of Object.entries(ext.client ?? {})) {
         if (clientKeys.has(name)) {
-            throw new ValidationError(`[turbine] prisma-compat: $extends \`client\` member "${name}" would shadow an existing client ` +
+            throw new ValidationError(`prisma-compat: $extends \`client\` member "${name}" would shadow an existing client ` +
                 'member (a model delegate or a client-level method). Rename it.');
         }
         client[name] = member;
@@ -2159,7 +2159,7 @@ function applyExtension(prev, ext, modelKeys, clientKeys) {
         }
         const canonical = modelKeys.get(key);
         if (!canonical) {
-            throw new ValidationError(`[turbine] prisma-compat: $extends \`model\` key "${key}" is not a model on this client. ` +
+            throw new ValidationError(`prisma-compat: $extends \`model\` key "${key}" is not a model on this client. ` +
                 `Known models: ${[...new Set(modelKeys.values())].sort().join(', ') || '(none)'}.`);
         }
         model.set(canonical, { ...(model.get(canonical) ?? {}), ...members });
@@ -2265,7 +2265,7 @@ export function createPrismaCompatClient(client, map, options = {}) {
      */
     const txRunRaw = (tx) => async (text, params) => {
         if (typeof tx.rawQuery !== 'function') {
-            throw decorate(new ValidationError('[turbine] prisma-compat: raw SQL inside $transaction needs a transaction client that can execute it ' +
+            throw decorate(new ValidationError('prisma-compat: raw SQL inside $transaction needs a transaction client that can execute it ' +
                 '(core TransactionClient.rawQuery). Refusing to run the statement on a pool connection, which would ' +
                 'silently place it outside the transaction.'), ctx.options.prismaErrorCodes);
         }
@@ -2310,7 +2310,7 @@ export function createPrismaCompatClient(client, map, options = {}) {
                             const batchables = arg.map((p, i) => {
                                 const b = batchableOf(p);
                                 if (!b) {
-                                    throw new ValidationError(`[turbine] prisma-compat: $transaction([...]) item ${i} is not a lazy model call. Pass un-awaited delegate calls (e.g. prisma.User.create(...)).`);
+                                    throw new ValidationError(`prisma-compat: $transaction([...]) item ${i} is not a lazy model call. Pass un-awaited delegate calls (e.g. prisma.User.create(...)).`);
                                 }
                                 return b;
                             });