turbine-orm 0.76.0 → 0.77.0

package/dist/cjs/cli/index.js

@@ -2650,7 +2650,7 @@ async function cmdMigrateDeploy(args, config) {
             (0, ui_js_1.error)('Deploy blocked by migration drift');
             (0, ui_js_1.errorLine)();
             for (const line of (0, migrate_js_1.formatChecksumMismatchError)(plan.mismatches).split('\n')) {
-                (0, ui_js_1.errorLine)(`${line.replace('[turbine] ', '')}`);
+                (0, ui_js_1.errorLine)(line);
             }
             (0, ui_js_1.errorLine)();
             process.exit(1);
@@ -2724,7 +2724,7 @@ async function confirmDestructive(report) {
     (0, ui_js_1.error)('DESTRUCTIVE MIGRATION DETECTED');
     (0, ui_js_1.newline)();
     for (const line of report.split('\n'))
-        console.log(`  ${line.includes('[turbine]') ? line.replace('[turbine] ', '') : line}`);
+        console.log(`  ${line}`);
     (0, ui_js_1.newline)();
     if (!process.stdin.isTTY) {
         console.log(`  ${(0, ui_js_1.dim)('Non-interactive shell: rerun with')} ${(0, ui_js_1.cyan)('--allow-destructive')} ${(0, ui_js_1.dim)('to proceed.')}`);

package/dist/cjs/cli/migrate.js

@@ -85,7 +85,7 @@ function assertNoEmbeddedTransactions(files, section) {
     if (offenders.length === 0)
         return;
     const lines = [
-        `[turbine] Refusing to run migrations that manage transactions themselves (${section.toUpperCase()} section):`,
+        `Refusing to run migrations that manage transactions themselves (${section.toUpperCase()} section):`,
         '',
     ];
     for (const o of offenders) {
@@ -337,7 +337,7 @@ function parseMigrationContent(content, source) {
     }
     if (!sawUpMarker) {
         throw new errors_js_1.MigrationError([
-            `[turbine] Migration file has no \`-- UP\` section marker${source ? `: ${source}` : '.'}`,
+            `Migration file has no \`-- UP\` section marker${source ? `: ${source}` : '.'}`,
             '',
             'A migration must contain a line reading `-- UP` (a `-- DOWN` line is optional).',
             'Without it the whole file is a header comment: nothing would run, and the',
@@ -616,7 +616,7 @@ function createMigration(migrationsDir, name, autoContent, options) {
         const recipe = exports.MIGRATION_RECIPES[options.recipe];
         if (!recipe) {
             const known = Object.keys(exports.MIGRATION_RECIPES).join(', ') || '(none)';
-            throw new errors_js_1.MigrationError(`[turbine] Unknown migration recipe "${options.recipe}". Available recipes: ${known}`);
+            throw new errors_js_1.MigrationError(`Unknown migration recipe "${options.recipe}". Available recipes: ${known}`);
         }
         // A recipe builds the BODY, below `-- UP`, where a newline is not merely a
         // comment break but directly executable, so it gets the safe name too.
@@ -848,7 +848,7 @@ function formatChecksumMismatchError(mismatches) {
     const modified = mismatches.filter((m) => m.type === 'modified');
     const missing = mismatches.filter((m) => m.type === 'missing');
     const lines = [
-        '[turbine] Migration drift detected, refusing to apply pending migrations.',
+        'Migration drift detected, refusing to apply pending migrations.',
         '',
         'Applied migrations should be immutable. The following files no longer match their applied state:',
         '',
@@ -965,7 +965,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
         const adapter = options?.adapter;
         const lock = await acquireMigrationLock(client, lockId, adapter, () => openLockConnection(connectionString));
         if (!lock.acquired) {
-            throw new errors_js_1.MigrationError('[turbine] Could not acquire migration lock, another migration is already running');
+            throw new errors_js_1.MigrationError('Could not acquire migration lock, another migration is already running');
         }
         try {
             await ensureTrackingTable(client, dialect);
@@ -1009,7 +1009,7 @@ async function migrateUp(connectionString, migrationsDir, options) {
             // pass `allowDestructive: true`. Safe-by-default is the whole point, a
             // DROP TABLE should never run just because a file exists.
             if (!options?.allowDestructive && destructive.length > 0) {
-                const lines = ['[turbine] Refusing to apply migrations containing DESTRUCTIVE statements:', ''];
+                const lines = ['Refusing to apply migrations containing DESTRUCTIVE statements:', ''];
                 for (const o of destructive) {
                     lines.push(`  ${o.file}`);
                     for (const h of o.hits) {
@@ -1189,7 +1189,7 @@ async function migrateDown(connectionString, migrationsDir, options) {
         const adapter = options?.adapter;
         const lock = await acquireMigrationLock(client, lockId, adapter, () => openLockConnection(connectionString));
         if (!lock.acquired) {
-            throw new errors_js_1.MigrationError('[turbine] Could not acquire migration lock, another migration is already running');
+            throw new errors_js_1.MigrationError('Could not acquire migration lock, another migration is already running');
         }
         try {
             await ensureTrackingTable(client, dialect);
@@ -1221,7 +1221,7 @@ async function migrateDown(connectionString, migrationsDir, options) {
                         offenders.push({ file: file.filename, hits });
                 }
                 if (offenders.length > 0) {
-                    const lines = ['[turbine] Refusing to roll back migrations whose DOWN sections are DESTRUCTIVE:', ''];
+                    const lines = ['Refusing to roll back migrations whose DOWN sections are DESTRUCTIVE:', ''];
                     for (const o of offenders) {
                         lines.push(`  ${o.file}`);
                         for (const h of o.hits) {

package/dist/cjs/cli/studio.js

@@ -411,6 +411,9 @@ function constantTimeEqual(a, b) {
 function unknownTableMessage(name, ctx) {
     const available = Object.keys(ctx.metadata.tables);
     const list = available.length ? available.join(', ') : '(none)';
+    // turbine-prefix-ok: every caller passes this straight to sendJson as an HTTP
+    // body, never to a TurbineError, so nothing prepends a `[TURBINE_EXXX]` tag
+    // and the prefix is the browser's only signal of who produced the message.
     return `[turbine] Unknown table "${name}" in schema "${ctx.options.schema}". Available: ${list}`;
 }
 // ---------------------------------------------------------------------------
@@ -836,17 +839,17 @@ function assertNoPiiPredicates(args, tableName, metadata, showPii) {
         metadata,
         hiddenReason: (table, column) => (isRedactedColumn(table, column, showPii) ? 'is PII-tagged and redacted' : null),
         refuseColumn: (table, column, reason) => {
-            throw new errors_js_1.ValidationError(`[turbine] Column "${column}" on "${table.name}" ${reason}, so it cannot be used ` +
+            throw new errors_js_1.ValidationError(`Column "${column}" on "${table.name}" ${reason}, so it cannot be used ` +
                 `in a where, orderBy, cursor, or distinct: filtering, sorting, paging, or de-duplicating on a hidden ` +
                 `value reveals it. Restart Studio with --show-pii to query it.`);
         },
         refuseDepth: (maxDepth) => {
-            throw new errors_js_1.ValidationError(`[turbine] Query is nested more than ${maxDepth} levels deep, which is past the point where ` +
+            throw new errors_js_1.ValidationError(`Query is nested more than ${maxDepth} levels deep, which is past the point where ` +
                 `Studio can prove it does not filter or sort on a PII-tagged and redacted column, so it is refused. ` +
                 `Flatten the query, or restart Studio with --show-pii.`);
         },
         refuseShape: (table, key) => {
-            throw new errors_js_1.ValidationError(`[turbine] Studio does not recognize "${key}" in a query on "${table.name}", so it cannot prove the ` +
+            throw new errors_js_1.ValidationError(`Studio does not recognize "${key}" in a query on "${table.name}", so it cannot prove the ` +
                 `query does not filter or sort on a PII-tagged and redacted column, and refuses it rather than ` +
                 `guessing. Remove it, or restart Studio with --show-pii.`);
         },

package/dist/cjs/client.js

@@ -295,7 +295,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 errors_js_1.ConnectionError(`[turbine] The ${source} is empty. Expected a Postgres connection string such as ` +
+        throw new errors_js_1.ConnectionError(`The ${source} is empty. Expected a Postgres connection string such as ` +
             '"postgresql://user:password@host:5432/database".');
     }
     const verdict = classifyConnectionString(value);
@@ -306,7 +306,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 errors_js_1.ConnectionError(`[turbine] The ${source} cannot be parsed as a connection string, pg rejects it with "Invalid URL" ` +
+        throw new errors_js_1.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}`);
     }
@@ -317,7 +317,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 errors_js_1.ConnectionError(`[turbine] The ${source} names no host: it has no "postgres://" or "postgresql://" scheme, so pg would ` +
+    throw new errors_js_1.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}`);
 }
@@ -398,7 +398,7 @@ function resolveIsolationLevel(level) {
         return undefined;
     const sql = (0, utils_js_1.ownLookup)(ISOLATION_LEVELS, level);
     if (sql === undefined) {
-        throw new errors_js_1.ValidationError(`[turbine] $transaction: unknown isolationLevel ${JSON.stringify(level)}. ` +
+        throw new errors_js_1.ValidationError(`$transaction: unknown isolationLevel ${JSON.stringify(level)}. ` +
             `Expected one of: ${Object.keys(ISOLATION_LEVELS).join(', ')} (case-sensitive).`);
     }
     return sql;
@@ -748,7 +748,7 @@ 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 errors_js_1.ValidationError('[turbine] TurbineClient requires schema metadata as its second argument. ' +
+            throw new errors_js_1.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
@@ -761,7 +761,7 @@ 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 errors_js_1.ValidationError(`[turbine] Table "${name}" in the schema passed to TurbineClient has no \`columns\` array, so this is ` +
+                throw new errors_js_1.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`.');
             }
@@ -1083,7 +1083,7 @@ class TurbineClient {
         if (value === undefined)
             return undefined;
         if (value !== 'null' && value !== 'preserve') {
-            throw new errors_js_1.ValidationError(`[turbine] Invalid temporalInfinity: ${JSON.stringify(value)}. Expected 'preserve' (default: read a Postgres ` +
+            throw new errors_js_1.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).');
@@ -1095,7 +1095,7 @@ class TurbineClient {
             return undefined;
         const matched = PLAN_CACHE_MODES.find((m) => m === mode);
         if (matched === undefined) {
-            throw new errors_js_1.ValidationError(`[turbine] Invalid planCacheMode: ${JSON.stringify(mode)}. Expected one of ${PLAN_CACHE_MODES.map((m) => `'${m}'`).join(', ')}.`);
+            throw new errors_js_1.ValidationError(`Invalid planCacheMode: ${JSON.stringify(mode)}. Expected one of ${PLAN_CACHE_MODES.map((m) => `'${m}'`).join(', ')}.`);
         }
         if (dialect.supportsPlanCacheMode !== true) {
             throw new errors_js_1.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, ' +
@@ -1194,7 +1194,7 @@ class TurbineClient {
         const settled = TurbineClient.utcTimestampParserMode;
         if (settled === undefined || settled === want)
             return;
-        throw new errors_js_1.ValidationError(`[turbine] utcTimestamps: ${want} conflicts with utcTimestamps: ${settled}, which an earlier TurbineClient ` +
+        throw new errors_js_1.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 ' +
@@ -1717,7 +1717,7 @@ class TurbineClient {
                 }
                 for (const [name, value] of Object.entries(options.sessionContext)) {
                     if (!GUC_NAME_REGEX.test(name)) {
-                        throw new errors_js_1.ValidationError(`[turbine] Invalid session-context GUC name "${name}", must match ` +
+                        throw new errors_js_1.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/cjs/dialect.js

@@ -117,7 +117,7 @@ exports.postgresDialect = {
     },
     buildBulkInsertStatement(input) {
         if (!input.columnArrayTypes || input.columnArrayTypes.length !== input.columns.length) {
-            throw new errors_js_1.ValidationError(`[turbine] createMany bulk insert into "${input.table}": columnArrayTypes must supply one UNNEST cast ` +
+            throw new errors_js_1.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/cjs/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/cjs/errors.js

@@ -465,11 +465,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.
@@ -490,14 +490,14 @@ 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(exports.TurbineErrorCode.NOT_FOUND, message, { cause });
@@ -520,7 +520,7 @@ class TimeoutError extends TurbineError {
      *   when wrapping a driver error rather than a client-side timer expiry.
      */
     constructor(timeoutMs, context = 'Query', options) {
-        super(exports.TurbineErrorCode.TIMEOUT, options?.message ?? `[turbine] ${context} timed out after ${timeoutMs}ms`, options);
+        super(exports.TurbineErrorCode.TIMEOUT, options?.message ?? `${context} timed out after ${timeoutMs}ms`, options);
         this.name = 'TimeoutError';
         this.timeoutMs = timeoutMs;
     }
@@ -593,7 +593,7 @@ exports.ConnectionError = ConnectionError;
  *   placeholder password. Never derived from the caller's value.
  */
 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.');
 }
@@ -617,7 +617,7 @@ exports.MigrationError = MigrationError;
 class CircularRelationError extends TurbineError {
     path;
     constructor(path) {
-        super(exports.TurbineErrorCode.CIRCULAR_RELATION, `[turbine] Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
+        super(exports.TurbineErrorCode.CIRCULAR_RELATION, `Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
         this.name = 'CircularRelationError';
         this.path = path;
     }
@@ -647,7 +647,7 @@ 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
@@ -678,7 +678,7 @@ 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
@@ -708,7 +708,7 @@ 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
@@ -754,7 +754,7 @@ 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(exports.TurbineErrorCode.DEADLOCK_DETECTED, message, { cause });
         this.name = 'DeadlockError';
@@ -787,9 +787,7 @@ 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(exports.TurbineErrorCode.SERIALIZATION_FAILURE, message, { cause });
         this.name = 'SerializationFailureError';
@@ -805,7 +803,7 @@ 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
@@ -834,7 +832,7 @@ 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
@@ -886,7 +884,7 @@ 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(exports.TurbineErrorCode.PIPELINE, message, { cause });
         this.name = 'PipelineError';
@@ -901,7 +899,7 @@ class OptimisticLockError extends TurbineError {
     versionField;
     expectedVersion;
     constructor(opts) {
-        super(exports.TurbineErrorCode.OPTIMISTIC_LOCK, `[turbine] Optimistic lock failed on "${opts.table}", ` +
+        super(exports.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;
@@ -920,7 +918,7 @@ class UnsupportedFeatureError extends TurbineError {
     feature;
     dialect;
     constructor(feature, dialect, hint) {
-        super(exports.TurbineErrorCode.UNSUPPORTED_FEATURE, `[turbine] ${feature} is unsupported on "${dialect}".${hint ? ` ${hint}` : ''}`);
+        super(exports.TurbineErrorCode.UNSUPPORTED_FEATURE, `${feature} is unsupported on "${dialect}".${hint ? ` ${hint}` : ''}`);
         this.name = 'UnsupportedFeatureError';
         this.feature = feature;
         this.dialect = dialect;
@@ -958,7 +956,7 @@ class ReadOnlyError extends TurbineError {
      *   and the refusal `reason` (default `'snapshot'`).
      */
     constructor(detail, options) {
-        super(exports.TurbineErrorCode.READ_ONLY, `[turbine] ${detail} Route writes to a writable primary.`, {
+        super(exports.TurbineErrorCode.READ_ONLY, `${detail} Route writes to a writable primary.`, {
             cause: options?.cause,
         });
         this.name = 'ReadOnlyError';
@@ -1132,7 +1130,7 @@ 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:
@@ -1142,9 +1140,7 @@ 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/cjs/generate.js

@@ -377,7 +377,7 @@ function isEmittableIdentifier(name) {
 function requireEmittable(derived, subject, role) {
     if (isEmittableIdentifier(derived))
         return;
-    throw new errors_js_1.ValidationError(`[turbine] Cannot generate code for ${subject}: it produces ${JSON.stringify(derived)} as ${role}, ` +
+    throw new errors_js_1.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/cjs/introspect.js

@@ -364,7 +364,7 @@ function assertSafeCatalogIdentifier(name, subject) {
     if (match === null)
         return;
     const code = match[0].charCodeAt(0).toString(16).padStart(4, '0');
-    throw new errors_js_1.ValidationError(`[turbine] Refusing to introspect ${subject}: its name contains the control character U+${code.toUpperCase()} ` +
+    throw new errors_js_1.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.`);
 }
@@ -461,22 +461,22 @@ function applyRelationRenames(schema, renames) {
     for (const [table, mapping] of Object.entries(renames)) {
         const meta = tables[table];
         if (!meta) {
-            throw new errors_js_1.ValidationError(`[turbine] relationNames: unknown table "${table}". Known tables: ${Object.keys(tables).join(', ')}.`);
+            throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] relationNames: table "${table}" has no relation "${from}". ` +
+                throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] relationNames: cannot rename "${table}.${from}" to "${to}", that relation already exists.`);
+                throw new errors_js_1.ValidationError(`relationNames: cannot rename "${table}.${from}" to "${to}", that relation already exists.`);
             }
             if (columnFields.has(to)) {
-                throw new errors_js_1.ValidationError(`[turbine] relationNames: cannot rename "${table}.${from}" to "${to}", a column on "${table}" ` +
+                throw new errors_js_1.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/cjs/mssql.js

@@ -663,11 +663,11 @@ exports.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 errors_js_1.ValidationError(`[turbine] SQL Server INSERT … VALUES is limited to ${MSSQL_MAX_INSERT_ROWS} rows per statement (got ${rowCount}). ` +
+            throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] SQL Server is limited to ${MSSQL_MAX_PARAMS} bound parameters per statement (got ${paramCount}). ` +
+            throw new errors_js_1.ValidationError(`SQL Server is limited to ${MSSQL_MAX_PARAMS} bound parameters per statement (got ${paramCount}). ` +
                 'Reduce the batch size.');
         }
         let n = 0;
@@ -915,7 +915,7 @@ function buildForJsonSubquery(dialect, ctx) {
         for (const [nestedRelName, nestedSpec] of sortedRelEntries(spec.with)) {
             const nestedRelDef = targetMeta.relations[nestedRelName];
             if (!nestedRelDef) {
-                throw new errors_js_1.RelationError(`[turbine] Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
+                throw new errors_js_1.RelationError(`Unknown relation "${nestedRelName}" on table "${targetTable}". ` +
                     (0, utils_js_1.availableClause)(Object.keys(targetMeta.relations), 'It has no relations.'));
             }
             const sub = ctx.recurse(nestedRelDef, nestedSpec, parentAlias, depth + 1, [...path, relDef.name]);
@@ -937,7 +937,7 @@ function buildForJsonSubquery(dialect, ctx) {
                 if (typeof dir === 'object' && dir !== null) {
                     const sortValue = dir.sort;
                     if (typeof sortValue !== 'string') {
-                        throw new errors_js_1.ValidationError(`[turbine] Nested orderBy on "${k}" (table "${targetTable}"): only plain directions and ` +
+                        throw new errors_js_1.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) {
@@ -950,7 +950,7 @@ function buildForJsonSubquery(dialect, ctx) {
                 // resolve on SQL Server too.
                 const col = targetMeta.columnMap[k] ?? (0, schema_js_1.camelToSnake)(k);
                 if (!targetMeta.allColumns.includes(col)) {
-                    throw new errors_js_1.ValidationError(`[turbine] Unknown field "${k}" in orderBy on table "${targetTable}". ` +
+                    throw new errors_js_1.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';
@@ -1016,7 +1016,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 errors_js_1.ValidationError(`[turbine] manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
+        throw new errors_js_1.ValidationError(`manyToMany relation "${relDef.name}" is missing a \`through\` junction descriptor.`);
     }
     const qTarget = q(targetTable);
     const qJunction = q(relDef.through.table);
@@ -1025,12 +1025,12 @@ function buildForJsonManyToMany(dialect, ctx, h) {
     // JOIN: junction.targetKey = target.<PK>.
     const targetKeys = (0, schema_js_1.normalizeKeyColumns)(relDef.through.targetKey);
     if (targetMeta.primaryKey.length === 0) {
-        throw new errors_js_1.ValidationError(`[turbine] manyToMany relation "${relDef.name}" targets table "${targetTable}" which has no primary key; ` +
+        throw new errors_js_1.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 errors_js_1.ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.targetKey has ${targetKeys.length} column(s) ` +
+        throw new errors_js_1.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 ');
@@ -1038,7 +1038,7 @@ function buildForJsonManyToMany(dialect, ctx, h) {
     const sourceKeys = (0, schema_js_1.normalizeKeyColumns)(relDef.through.sourceKey);
     const refKeys = (0, schema_js_1.normalizeKeyColumns)(relDef.referenceKey);
     if (sourceKeys.length !== refKeys.length) {
-        throw new errors_js_1.ValidationError(`[turbine] manyToMany relation "${relDef.name}": through.sourceKey has ${sourceKeys.length} column(s) ` +
+        throw new errors_js_1.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 ');
@@ -1320,13 +1320,13 @@ async function loadMssql() {
         mod = (await (0, optional_peer_import_cjs_1.default)('mssql'));
     }
     catch (err) {
-        throw new errors_js_1.ConnectionError("[turbine] turbine-orm/mssql requires the optional peer dependency 'mssql'. Install it: npm i mssql. " +
+        throw new errors_js_1.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 errors_js_1.ConnectionError("[turbine] Loaded 'mssql' but it is missing ConnectionPool/Request exports.");
+        throw new errors_js_1.ConnectionError("Loaded 'mssql' but it is missing ConnectionPool/Request exports.");
     }
     return ns;
 }
@@ -1336,7 +1336,7 @@ async function loadMssql() {
  */
 function assertSupportedVersion(majorVersion) {
     if (majorVersion > 0 && majorVersion < 13) {
-        throw new errors_js_1.ConnectionError(`[turbine] turbine-orm/mssql requires SQL Server 2016+ (FOR JSON / OPENJSON); got major version ${majorVersion}.`);
+        throw new errors_js_1.ConnectionError(`turbine-orm/mssql requires SQL Server 2016+ (FOR JSON / OPENJSON); got major version ${majorVersion}.`);
     }
 }
 function isMssqlPool(x) {

package/dist/cjs/mysql.js

@@ -1026,7 +1026,7 @@ async function introspectMysql(options) {
             schemaName = rows[0]?.db ?? '';
         }
         if (!schemaName) {
-            throw new errors_js_1.ConnectionError('[turbine] Could not determine the MySQL database to introspect, pass a database in the connection string or a `schema` option.');
+            throw new errors_js_1.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()`
@@ -1101,12 +1101,12 @@ async function loadCreatePool() {
         mod = (await (0, optional_peer_import_cjs_1.default)('mysql2/promise'));
     }
     catch (err) {
-        throw new errors_js_1.ConnectionError("[turbine] turbine-orm/mysql requires the optional peer dependency 'mysql2'. Install it: npm i mysql2. " +
+        throw new errors_js_1.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 errors_js_1.ConnectionError("[turbine] Loaded 'mysql2/promise' but it has no createPool export.");
+        throw new errors_js_1.ConnectionError("Loaded 'mysql2/promise' but it has no createPool export.");
     }
     return createPool;
 }
@@ -1116,12 +1116,12 @@ async function loadCreatePool() {
  */
 function assertSupportedVersion(version) {
     if (/mariadb/i.test(version)) {
-        throw new errors_js_1.ConnectionError(`[turbine] MariaDB is not supported by turbine-orm/mysql (got "${version}"). Use MySQL 8.0+.`);
+        throw new errors_js_1.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 errors_js_1.ConnectionError(`[turbine] turbine-orm/mysql requires MySQL 8.0+ (5.7 lacks JSON_ARRAYAGG); got "${version}".`);
+        throw new errors_js_1.ConnectionError(`turbine-orm/mysql requires MySQL 8.0+ (5.7 lacks JSON_ARRAYAGG); got "${version}".`);
     }
 }
 function isMysql2Pool(x) {