turbine-orm 0.76.0 → 0.77.0

package/dist/client.js

@@ -288,7 +288,7 @@ function assertUsableConnectionString(value, source) {
     // to `%20%20%20`, and resolve it against its placeholder host. Naming it as
     // empty is more useful than reporting the phantom host.
     if (value.trim().length === 0) {
-        throw new ConnectionError(`[turbine] The ${source} is empty. Expected a Postgres connection string such as ` +
+        throw new ConnectionError(`The ${source} is empty. Expected a Postgres connection string such as ` +
             '"postgresql://user:password@host:5432/database".');
     }
     const verdict = classifyConnectionString(value);
@@ -299,7 +299,7 @@ function assertUsableConnectionString(value, source) {
     const tail = '(Check for a missing "//", a stray quote copied out of a .env file, or a shell-truncated value.) ' +
         'The value is not included here because it may contain a password.';
     if (verdict.kind === 'unparseable') {
-        throw new ConnectionError(`[turbine] The ${source} cannot be parsed as a connection string, pg rejects it with "Invalid URL" ` +
+        throw new ConnectionError(`The ${source} cannot be parsed as a connection string, pg rejects it with "Invalid URL" ` +
             '(most often a non-numeric port). Expected something like ' +
             `"postgresql://user:password@host:5432/database". ${tail}`);
     }
@@ -310,7 +310,7 @@ function assertUsableConnectionString(value, source) {
     const keywordForm = /^[A-Za-z_][A-Za-z0-9_]*\s*=/.test(value.trimStart())
         ? 'It looks like a libpq "host=… dbname=…" keyword/value string, which node-postgres does not support. '
         : '';
-    throw new ConnectionError(`[turbine] The ${source} names no host: it has no "postgres://" or "postgresql://" scheme, so pg would ` +
+    throw new ConnectionError(`The ${source} names no host: it has no "postgres://" or "postgresql://" scheme, so pg would ` +
         `resolve it as a relative URL and try to connect to its internal placeholder host. ${keywordForm}` +
         `Expected something like "postgresql://user:password@host:5432/database". ${tail}`);
 }
@@ -391,7 +391,7 @@ function resolveIsolationLevel(level) {
         return undefined;
     const sql = ownLookup(ISOLATION_LEVELS, level);
     if (sql === undefined) {
-        throw new ValidationError(`[turbine] $transaction: unknown isolationLevel ${JSON.stringify(level)}. ` +
+        throw new ValidationError(`$transaction: unknown isolationLevel ${JSON.stringify(level)}. ` +
             `Expected one of: ${Object.keys(ISOLATION_LEVELS).join(', ')} (case-sensitive).`);
     }
     return sql;
@@ -740,7 +740,7 @@ export class TurbineClient {
             // output), not runtime SchemaMetadata, so name the conversion rather than
             // just the requirement.
             const looksLikeSchemaDef = schema !== null && typeof schema === 'object' && Object.hasOwn(schema, 'name') === false;
-            throw new ValidationError('[turbine] TurbineClient requires schema metadata as its second argument. ' +
+            throw new ValidationError('TurbineClient requires schema metadata as its second argument. ' +
                 'Run `npx turbine generate` and use the generated client (`turbine()` from your output dir), ' +
                 'or pass the generated `schemaMetadata` object: new TurbineClient(config, schemaMetadata).' +
                 (looksLikeSchemaDef
@@ -753,7 +753,7 @@ export class TurbineClient {
         // the cause. Validate one table's shape here, where the fix is obvious.
         for (const [name, meta] of Object.entries(schema.tables)) {
             if (!meta || typeof meta !== 'object' || !Array.isArray(meta.columns)) {
-                throw new ValidationError(`[turbine] Table "${name}" in the schema passed to TurbineClient has no \`columns\` array, so this is ` +
+                throw new ValidationError(`Table "${name}" in the schema passed to TurbineClient has no \`columns\` array, so this is ` +
                     'not runtime SchemaMetadata. A `defineSchema()` result is a SchemaDef: convert it with ' +
                     '`schemaDefToMetadata(def)`, or use the metadata emitted by `npx turbine generate`.');
             }
@@ -1075,7 +1075,7 @@ export class TurbineClient {
         if (value === undefined)
             return undefined;
         if (value !== 'null' && value !== 'preserve') {
-            throw new ValidationError(`[turbine] Invalid temporalInfinity: ${JSON.stringify(value)}. Expected 'preserve' (default: read a Postgres ` +
+            throw new ValidationError(`Invalid temporalInfinity: ${JSON.stringify(value)}. Expected 'preserve' (default: read a Postgres ` +
                 'temporal `infinity` as the JS number `Infinity` / `-Infinity`, which round-trips through a write ' +
                 "but breaks the declared `Date` type) or 'null' (read it as null, which serializes cleanly but " +
                 'makes it indistinguishable from a stored NULL, so a read-modify-write destroys the value).');
@@ -1087,7 +1087,7 @@ export class TurbineClient {
             return undefined;
         const matched = PLAN_CACHE_MODES.find((m) => m === mode);
         if (matched === undefined) {
-            throw new ValidationError(`[turbine] Invalid planCacheMode: ${JSON.stringify(mode)}. Expected one of ${PLAN_CACHE_MODES.map((m) => `'${m}'`).join(', ')}.`);
+            throw new ValidationError(`Invalid planCacheMode: ${JSON.stringify(mode)}. Expected one of ${PLAN_CACHE_MODES.map((m) => `'${m}'`).join(', ')}.`);
         }
         if (dialect.supportsPlanCacheMode !== true) {
             throw new UnsupportedFeatureError(`The planCacheMode option (plan_cache_mode = ${matched})`, dialect.name, '`plan_cache_mode` is a PostgreSQL plan-cache setting with no equivalent on this engine. Remove the option, ' +
@@ -1186,7 +1186,7 @@ export class TurbineClient {
         const settled = TurbineClient.utcTimestampParserMode;
         if (settled === undefined || settled === want)
             return;
-        throw new ValidationError(`[turbine] utcTimestamps: ${want} conflicts with utcTimestamps: ${settled}, which an earlier TurbineClient ` +
+        throw new ValidationError(`utcTimestamps: ${want} conflicts with utcTimestamps: ${settled}, which an earlier TurbineClient ` +
             'in this process already applied. The zone-less temporal READ parsers (pg OIDs 1114, 1082, 1115, 1182) are ' +
             'process-global, so they cannot ' +
             'differ per client, while the WRITE side is per client. Serving both values would give this client a ' +
@@ -1709,7 +1709,7 @@ export class TurbineClient {
                 }
                 for (const [name, value] of Object.entries(options.sessionContext)) {
                     if (!GUC_NAME_REGEX.test(name)) {
-                        throw new ValidationError(`[turbine] Invalid session-context GUC name "${name}", must match ` +
+                        throw new ValidationError(`Invalid session-context GUC name "${name}", must match ` +
                             '/^[A-Za-z_][A-Za-z0-9_]*(\\.[A-Za-z_][A-Za-z0-9_]*)?$/ (optionally namespaced, e.g. "app.current_tenant")');
                     }
                     const cfg = this.dialect.buildSetSessionConfig(name, String(value));

package/dist/dialect.js

@@ -81,7 +81,7 @@ export const postgresDialect = {
     },
     buildBulkInsertStatement(input) {
         if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
-            throw new ValidationError(`[turbine] createMany bulk insert into "${input.table}": columnArrayTypes must supply one UNNEST cast ` +
+            throw new ValidationError(`createMany bulk insert into "${input.table}": columnArrayTypes must supply one UNNEST cast ` +
                 `per column, got ${input.columnArrayTypes?.length ?? 0} for ${input.columns.length} columns ` +
                 `(${input.columns.join(', ')}). Schema metadata is missing a pgType for at least one column; ` +
                 'regenerate it with `npx turbine generate`.');

package/dist/errors.d.ts

@@ -152,11 +152,11 @@ export declare function describeTargetForMessage(target: unknown): string;
  * When called with an options object and no explicit `message`, a Prisma-style
  * message is built automatically. By default, only the where-clause keys are
  * shown to avoid leaking PII into logs:
- *   `[turbine] findUniqueOrThrow on "users" found no record matching where: { id }`
+ *   `[TURBINE_E001] findUniqueOrThrow on "users" found no record matching where: { id }`
  *
  * Set `setErrorMessageMode('verbose')` (or pass `errorMessages: 'verbose'` to
  * the TurbineClient constructor) to include the full where values:
- *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ *   `[TURBINE_E001] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
  *
  * The full `where` object, `table`, and `operation` are always available as
  * structured properties on the error instance regardless of mode.

package/dist/errors.js

@@ -452,11 +452,11 @@ function renderWhereForMessage(where, mode) {
  * When called with an options object and no explicit `message`, a Prisma-style
  * message is built automatically. By default, only the where-clause keys are
  * shown to avoid leaking PII into logs:
- *   `[turbine] findUniqueOrThrow on "users" found no record matching where: { id }`
+ *   `[TURBINE_E001] findUniqueOrThrow on "users" found no record matching where: { id }`
  *
  * Set `setErrorMessageMode('verbose')` (or pass `errorMessages: 'verbose'` to
  * the TurbineClient constructor) to include the full where values:
- *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ *   `[TURBINE_E001] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
  *
  * The full `where` object, `table`, and `operation` are always available as
  * structured properties on the error instance regardless of mode.
@@ -477,14 +477,14 @@ export class NotFoundError extends TurbineError {
         if (!message) {
             if (operation && table) {
                 const wherePart = where !== undefined ? ` matching where: ${renderWhereForMessage(where, currentErrorMessageMode())}` : '';
-                message = `[turbine] ${operation} on "${table}" found no record${wherePart}`;
+                message = `${operation} on "${table}" found no record${wherePart}`;
             }
             else if (table) {
                 const wherePart = where !== undefined ? ` matching where ${renderWhereForMessage(where, currentErrorMessageMode())}` : '';
-                message = `[turbine] No record found in "${table}"${wherePart}`;
+                message = `No record found in "${table}"${wherePart}`;
             }
             else {
-                message = '[turbine] Record not found';
+                message = 'Record not found';
             }
         }
         super(TurbineErrorCode.NOT_FOUND, message, { cause });
@@ -506,7 +506,7 @@ export class TimeoutError extends TurbineError {
      *   when wrapping a driver error rather than a client-side timer expiry.
      */
     constructor(timeoutMs, context = 'Query', options) {
-        super(TurbineErrorCode.TIMEOUT, options?.message ?? `[turbine] ${context} timed out after ${timeoutMs}ms`, options);
+        super(TurbineErrorCode.TIMEOUT, options?.message ?? `${context} timed out after ${timeoutMs}ms`, options);
         this.name = 'TimeoutError';
         this.timeoutMs = timeoutMs;
     }
@@ -576,7 +576,7 @@ export class ConnectionError extends TurbineError {
  *   placeholder password. Never derived from the caller's value.
  */
 export function malformedConnectionStringMessage(engine, example) {
-    return (`[turbine] The ${engine} connection string could not be parsed as a URL. Expected something like "${example}". ` +
+    return (`The ${engine} connection string could not be parsed as a URL. Expected something like "${example}". ` +
         '(Check for a missing "//", a stray quote copied out of a .env file, or a shell-truncated value.) ' +
         'The value is not included here because it may contain a password.');
 }
@@ -598,7 +598,7 @@ export class MigrationError extends TurbineError {
 export class CircularRelationError extends TurbineError {
     path;
     constructor(path) {
-        super(TurbineErrorCode.CIRCULAR_RELATION, `[turbine] Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
+        super(TurbineErrorCode.CIRCULAR_RELATION, `Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
         this.name = 'CircularRelationError';
         this.path = path;
     }
@@ -627,7 +627,7 @@ export class UniqueConstraintError extends TurbineError {
         if (!message) {
             const constraintPart = constraint ? ` on ${constraint}` : '';
             const columnsPart = columns && columns.length > 0 ? ` (${columns.join(', ')})` : '';
-            message = `[turbine] Unique constraint violation${constraintPart}${columnsPart}`;
+            message = `Unique constraint violation${constraintPart}${columnsPart}`;
             // 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
@@ -657,7 +657,7 @@ export class ForeignKeyError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const constraintPart = constraint ? ` on ${constraint}` : '';
-            message = `[turbine] Foreign key constraint violation${constraintPart}`;
+            message = `Foreign key constraint violation${constraintPart}`;
             // 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
@@ -686,7 +686,7 @@ export class NotNullViolationError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const columnPart = column ? ` on column "${column}"` : '';
-            message = `[turbine] NOT NULL constraint violation${columnPart}`;
+            message = `NOT NULL constraint violation${columnPart}`;
             // 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
@@ -731,7 +731,7 @@ export class DeadlockError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const pgMessage = cause?.message;
-            message = pgMessage ? `[turbine] Deadlock detected: ${pgMessage}` : '[turbine] Deadlock detected';
+            message = pgMessage ? `Deadlock detected: ${pgMessage}` : 'Deadlock detected';
         }
         super(TurbineErrorCode.DEADLOCK_DETECTED, message, { cause });
         this.name = 'DeadlockError';
@@ -763,9 +763,7 @@ export class SerializationFailureError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const pgMessage = cause?.message;
-            message = pgMessage
-                ? `[turbine] Serializable transaction conflict: ${pgMessage}`
-                : '[turbine] Serializable transaction conflict';
+            message = pgMessage ? `Serializable transaction conflict: ${pgMessage}` : 'Serializable transaction conflict';
         }
         super(TurbineErrorCode.SERIALIZATION_FAILURE, message, { cause });
         this.name = 'SerializationFailureError';
@@ -780,7 +778,7 @@ export class CheckConstraintError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const constraintPart = constraint ? ` on ${constraint}` : '';
-            message = `[turbine] Check constraint violation${constraintPart}`;
+            message = `Check constraint violation${constraintPart}`;
             // 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
@@ -808,7 +806,7 @@ export class ExclusionConstraintError extends TurbineError {
         let message = opts.message;
         if (!message) {
             const constraintPart = constraint ? ` on ${constraint}` : '';
-            message = `[turbine] Exclusion constraint violation${constraintPart}`;
+            message = `Exclusion constraint violation${constraintPart}`;
             // 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
@@ -859,7 +857,7 @@ export class PipelineError extends TurbineError {
         const { results, failedIndex, failedTag, cause } = opts;
         const failedCount = results.filter((r) => r.status === 'error').length;
         const message = opts.message ??
-            `[turbine] Pipeline completed with ${failedCount} error(s) out of ${results.length} queries` +
+            `Pipeline completed with ${failedCount} error(s) out of ${results.length} queries` +
                 (failedTag ? ` (first failure: ${failedTag} at index ${failedIndex})` : '');
         super(TurbineErrorCode.PIPELINE, message, { cause });
         this.name = 'PipelineError';
@@ -873,7 +871,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, `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;
@@ -891,7 +889,7 @@ export class UnsupportedFeatureError extends TurbineError {
     feature;
     dialect;
     constructor(feature, dialect, hint) {
-        super(TurbineErrorCode.UNSUPPORTED_FEATURE, `[turbine] ${feature} is unsupported on "${dialect}".${hint ? ` ${hint}` : ''}`);
+        super(TurbineErrorCode.UNSUPPORTED_FEATURE, `${feature} is unsupported on "${dialect}".${hint ? ` ${hint}` : ''}`);
         this.name = 'UnsupportedFeatureError';
         this.feature = feature;
         this.dialect = dialect;
@@ -928,7 +926,7 @@ export class ReadOnlyError extends TurbineError {
      *   and the refusal `reason` (default `'snapshot'`).
      */
     constructor(detail, options) {
-        super(TurbineErrorCode.READ_ONLY, `[turbine] ${detail} Route writes to a writable primary.`, {
+        super(TurbineErrorCode.READ_ONLY, `${detail} Route writes to a writable primary.`, {
             cause: options?.cause,
         });
         this.name = 'ReadOnlyError';
@@ -1101,7 +1099,7 @@ export function wrapPgError(err) {
             // Turbine did not set the deadline (that lives in Postgres config), so
             // there is no client-side budget to report → timeoutMs = 0.
             return new TimeoutError(0, 'Query', {
-                message: '[turbine] Query canceled by server-side statement_timeout',
+                message: 'Query canceled by server-side statement_timeout',
                 cause: err,
             });
         default:
@@ -1111,9 +1109,7 @@ export function wrapPgError(err) {
                 // plain-object map would happily resolve `constructor` or `toString`
                 // to a function and interpolate it into the message.
                 const hint = Object.hasOwn(CONNECTION_ERROR_HINTS, e.code) ? CONNECTION_ERROR_HINTS[e.code] : undefined;
-                const head = pgMessage
-                    ? `[turbine] Database connection error: ${pgMessage}`
-                    : `[turbine] Database connection error (${e.code})`;
+                const head = pgMessage ? `Database connection error: ${pgMessage}` : `Database connection error (${e.code})`;
                 return new ConnectionError(hint ? `${head} (${e.code}) ${hint}` : head, { cause: err, sqlstate: e.code });
             }
             return err;

package/dist/generate.js

@@ -363,7 +363,7 @@ export function isEmittableIdentifier(name) {
 function requireEmittable(derived, subject, role) {
     if (isEmittableIdentifier(derived))
         return;
-    throw new ValidationError(`[turbine] Cannot generate code for ${subject}: it produces ${JSON.stringify(derived)} as ${role}, ` +
+    throw new ValidationError(`Cannot generate code for ${subject}: it produces ${JSON.stringify(derived)} as ${role}, ` +
         `which is not a valid TypeScript identifier. Rename the database object, or exclude it from generation ` +
         `(introspect \`exclude\`).`);
 }

package/dist/introspect.js

@@ -337,7 +337,7 @@ export function assertSafeCatalogIdentifier(name, subject) {
     if (match === null)
         return;
     const code = match[0].charCodeAt(0).toString(16).padStart(4, '0');
-    throw new ValidationError(`[turbine] Refusing to introspect ${subject}: its name contains the control character U+${code.toUpperCase()} ` +
+    throw new ValidationError(`Refusing to introspect ${subject}: its name contains the control character U+${code.toUpperCase()} ` +
         `at position ${match.index}. Such a name cannot be safely emitted into generated code, SQL comments, or ` +
         `tooling output. Rename the database object, or exclude it from introspection.`);
 }
@@ -434,22 +434,22 @@ export function applyRelationRenames(schema, renames) {
     for (const [table, mapping] of Object.entries(renames)) {
         const meta = tables[table];
         if (!meta) {
-            throw new ValidationError(`[turbine] relationNames: unknown table "${table}". Known tables: ${Object.keys(tables).join(', ')}.`);
+            throw new ValidationError(`relationNames: unknown table "${table}". Known tables: ${Object.keys(tables).join(', ')}.`);
         }
         const relations = { ...meta.relations };
         const columnFields = new Set(Object.values(meta.columnMap));
         for (const [from, to] of Object.entries(mapping)) {
             if (!Object.hasOwn(relations, from)) {
-                throw new ValidationError(`[turbine] relationNames: table "${table}" has no relation "${from}". ` +
+                throw new ValidationError(`relationNames: table "${table}" has no relation "${from}". ` +
                     `Derived relations: ${Object.keys(relations).join(', ') || '(none)'}.`);
             }
             if (from === to)
                 continue;
             if (Object.hasOwn(relations, to)) {
-                throw new ValidationError(`[turbine] relationNames: cannot rename "${table}.${from}" to "${to}", that relation already exists.`);
+                throw new ValidationError(`relationNames: cannot rename "${table}.${from}" to "${to}", that relation already exists.`);
             }
             if (columnFields.has(to)) {
-                throw new ValidationError(`[turbine] relationNames: cannot rename "${table}.${from}" to "${to}", a column on "${table}" ` +
+                throw new ValidationError(`relationNames: cannot rename "${table}.${from}" to "${to}", a column on "${table}" ` +
                     `already uses that field name, and a relation must never shadow a column.`);
             }
             const def = relations[from];

package/dist/mssql.js

@@ -652,11 +652,11 @@ export const mssqlDialect = {
         const rowCount = input.rowValues.length;
         const paramCount = input.rowValues.reduce((n, row) => n + row.length, 0);
         if (rowCount > MSSQL_MAX_INSERT_ROWS) {
-            throw new ValidationError(`[turbine] SQL Server INSERT … VALUES is limited to ${MSSQL_MAX_INSERT_ROWS} rows per statement (got ${rowCount}). ` +
+            throw new ValidationError(`SQL Server INSERT … VALUES is limited to ${MSSQL_MAX_INSERT_ROWS} rows per statement (got ${rowCount}). ` +
                 'Chunk the data or use individual create() calls.');
         }
         if (paramCount > MSSQL_MAX_PARAMS) {
-            throw new ValidationError(`[turbine] SQL Server is limited to ${MSSQL_MAX_PARAMS} bound parameters per statement (got ${paramCount}). ` +
+            throw new ValidationError(`SQL Server is limited to ${MSSQL_MAX_PARAMS} bound parameters per statement (got ${paramCount}). ` +
                 'Reduce the batch size.');
         }
         let n = 0;
@@ -904,7 +904,7 @@ function buildForJsonSubquery(dialect, ctx) {
         for (const [nestedRelName, nestedSpec] of sortedRelEntries(spec.with)) {
             const nestedRelDef = targetMeta.relations[nestedRelName];
             if (!nestedRelDef) {
-                throw new RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                throw new RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                     availableClause(Object.keys(targetMeta.relations), 'It has no relations.'));
             }
             const sub = ctx.recurse(nestedRelDef, nestedSpec, parentAlias, depth + 1, [...path, relDef.name]);
@@ -926,7 +926,7 @@ function buildForJsonSubquery(dialect, ctx) {
                 if (typeof dir === 'object' && dir !== null) {
                     const sortValue = dir.sort;
                     if (typeof sortValue !== 'string') {
-                        throw new ValidationError(`[turbine] Nested orderBy on "${k}" (table "${targetTable}"): only plain directions and ` +
+                        throw new ValidationError(`Nested orderBy on "${k}" (table "${targetTable}"): only plain directions and ` +
                             `{ sort } specs are supported inside a relation orderBy on SQL Server.`);
                     }
                     if (dir.nulls !== undefined) {
@@ -939,7 +939,7 @@ function buildForJsonSubquery(dialect, ctx) {
                 // resolve on SQL Server too.
                 const col = targetMeta.columnMap[k] ?? camelToSnake(k);
                 if (!targetMeta.allColumns.includes(col)) {
-                    throw new ValidationError(`[turbine] Unknown field "${k}" in orderBy on table "${targetTable}". ` +
+                    throw new ValidationError(`Unknown field "${k}" in orderBy on table "${targetTable}". ` +
                         `Known fields: ${Object.keys(targetMeta.columnMap).join(', ') || '(none)'}.`);
                 }
                 const safeDir = String(rawDir).toLowerCase() === 'desc' ? 'DESC' : 'ASC';
@@ -1005,7 +1005,7 @@ function buildForJsonManyToMany(dialect, ctx, h) {
     const { relDef, spec, params, parentRef, alias, targetTable, targetMeta } = ctx;
     const q = (name) => dialect.quoteIdentifier(name);
     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 qTarget = q(targetTable);
     const qJunction = q(relDef.through.table);
@@ -1014,12 +1014,12 @@ function buildForJsonManyToMany(dialect, ctx, h) {
     // JOIN: junction.targetKey = target.<PK>.
     const targetKeys = normalizeKeyColumns(relDef.through.targetKey);
     if (targetMeta.primaryKey.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 determine the join column.');
     }
     const targetPk = targetMeta.primaryKey;
     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}.`);
     }
     const joinOn = targetKeys.map((jcol, i) => `${jalias}.${q(jcol)} = ${alias}.${q(targetPk[i])}`).join(' AND ');
@@ -1027,7 +1027,7 @@ function buildForJsonManyToMany(dialect, ctx, h) {
     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}.`);
     }
     const correlation = sourceKeys.map((jcol, i) => `${jalias}.${q(jcol)} = ${qParent}.${q(refKeys[i])}`).join(' AND ');
@@ -1309,13 +1309,13 @@ async function loadMssql() {
         mod = (await importOptionalPeer('mssql'));
     }
     catch (err) {
-        throw new ConnectionError("[turbine] turbine-orm/mssql requires the optional peer dependency 'mssql'. Install it: npm i mssql. " +
+        throw new ConnectionError("turbine-orm/mssql requires the optional peer dependency 'mssql'. Install it: npm i mssql. " +
             `(${err.message})`);
     }
     // `mssql` is a CommonJS module; the namespace may be on `default` under ESM interop.
     const ns = (mod.default ?? mod);
     if (typeof ns.ConnectionPool !== 'function' || typeof ns.Request !== 'function') {
-        throw new ConnectionError("[turbine] Loaded 'mssql' but it is missing ConnectionPool/Request exports.");
+        throw new ConnectionError("Loaded 'mssql' but it is missing ConnectionPool/Request exports.");
     }
     return ns;
 }
@@ -1325,7 +1325,7 @@ async function loadMssql() {
  */
 function assertSupportedVersion(majorVersion) {
     if (majorVersion > 0 && majorVersion < 13) {
-        throw new ConnectionError(`[turbine] turbine-orm/mssql requires SQL Server 2016+ (FOR JSON / OPENJSON); got major version ${majorVersion}.`);
+        throw new ConnectionError(`turbine-orm/mssql requires SQL Server 2016+ (FOR JSON / OPENJSON); got major version ${majorVersion}.`);
     }
 }
 function isMssqlPool(x) {

package/dist/mysql.js

@@ -1015,7 +1015,7 @@ export async function introspectMysql(options) {
             schemaName = rows[0]?.db ?? '';
         }
         if (!schemaName) {
-            throw new ConnectionError('[turbine] Could not determine the MySQL database to introspect, pass a database in the connection string or a `schema` option.');
+            throw new ConnectionError('Could not determine the MySQL database to introspect, pass a database in the connection string or a `schema` option.');
         }
         // `await` is LOAD-BEARING, not stylistic: `return somePromise` inside a
         // try/finally runs the finally BEFORE the promise settles, so `pool.end()`
@@ -1090,12 +1090,12 @@ async function loadCreatePool() {
         mod = (await importOptionalPeer('mysql2/promise'));
     }
     catch (err) {
-        throw new ConnectionError("[turbine] turbine-orm/mysql requires the optional peer dependency 'mysql2'. Install it: npm i mysql2. " +
+        throw new ConnectionError("turbine-orm/mysql requires the optional peer dependency 'mysql2'. Install it: npm i mysql2. " +
             `(${err.message})`);
     }
     const createPool = mod.createPool ?? mod.default?.createPool;
     if (typeof createPool !== 'function') {
-        throw new ConnectionError("[turbine] Loaded 'mysql2/promise' but it has no createPool export.");
+        throw new ConnectionError("Loaded 'mysql2/promise' but it has no createPool export.");
     }
     return createPool;
 }
@@ -1105,12 +1105,12 @@ async function loadCreatePool() {
  */
 function assertSupportedVersion(version) {
     if (/mariadb/i.test(version)) {
-        throw new ConnectionError(`[turbine] MariaDB is not supported by turbine-orm/mysql (got "${version}"). Use MySQL 8.0+.`);
+        throw new ConnectionError(`MariaDB is not supported by turbine-orm/mysql (got "${version}"). Use MySQL 8.0+.`);
     }
     const m = /^(\d+)\.(\d+)/.exec(version);
     const major = m ? Number(m[1]) : 0;
     if (major < 8) {
-        throw new ConnectionError(`[turbine] turbine-orm/mysql requires MySQL 8.0+ (5.7 lacks JSON_ARRAYAGG); got "${version}".`);
+        throw new ConnectionError(`turbine-orm/mysql requires MySQL 8.0+ (5.7 lacks JSON_ARRAYAGG); got "${version}".`);
     }
 }
 function isMysql2Pool(x) {