turbine-orm 0.76.0 → 0.77.0

package/dist/cjs/query/where.js

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

package/dist/cjs/query/writes.js

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

package/dist/cjs/realtime.js

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

package/dist/cjs/schema-metadata.js

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

package/dist/cjs/schema-sql.js

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

package/dist/cjs/seed.js

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

package/dist/cjs/sqlite.js

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

package/dist/cjs/typed-sql.js

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

package/dist/cli/index.js

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

package/dist/cli/migrate.js

@@ -55,7 +55,7 @@ export 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) {
@@ -307,7 +307,7 @@ export function parseMigrationContent(content, source) {
     }
     if (!sawUpMarker) {
         throw new 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',
@@ -586,7 +586,7 @@ export function createMigration(migrationsDir, name, autoContent, options) {
         const recipe = MIGRATION_RECIPES[options.recipe];
         if (!recipe) {
             const known = Object.keys(MIGRATION_RECIPES).join(', ') || '(none)';
-            throw new MigrationError(`[turbine] Unknown migration recipe "${options.recipe}". Available recipes: ${known}`);
+            throw new 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.
@@ -818,7 +818,7 @@ export 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:',
         '',
@@ -935,7 +935,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
         const adapter = options?.adapter;
         const lock = await acquireMigrationLock(client, lockId, adapter, () => openLockConnection(connectionString));
         if (!lock.acquired) {
-            throw new MigrationError('[turbine] Could not acquire migration lock, another migration is already running');
+            throw new MigrationError('Could not acquire migration lock, another migration is already running');
         }
         try {
             await ensureTrackingTable(client, dialect);
@@ -979,7 +979,7 @@ export 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) {
@@ -1159,7 +1159,7 @@ export async function migrateDown(connectionString, migrationsDir, options) {
         const adapter = options?.adapter;
         const lock = await acquireMigrationLock(client, lockId, adapter, () => openLockConnection(connectionString));
         if (!lock.acquired) {
-            throw new MigrationError('[turbine] Could not acquire migration lock, another migration is already running');
+            throw new MigrationError('Could not acquire migration lock, another migration is already running');
         }
         try {
             await ensureTrackingTable(client, dialect);
@@ -1191,7 +1191,7 @@ export 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/cli/studio.js

@@ -391,6 +391,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}`;
 }
 // ---------------------------------------------------------------------------
@@ -816,17 +819,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 ValidationError(`[turbine] Column "${column}" on "${table.name}" ${reason}, so it cannot be used ` +
+            throw new 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 ValidationError(`[turbine] Query is nested more than ${maxDepth} levels deep, which is past the point where ` +
+            throw new 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 ValidationError(`[turbine] Studio does not recognize "${key}" in a query on "${table.name}", so it cannot prove the ` +
+            throw new 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.`);
         },