@llmops/core 0.4.8-beta.3 → 0.4.8-beta.5

package/dist/{bun-sqlite-dialect-DQa87s1D.cjs → bun-sqlite-dialect-lNniX_lj.cjs}

@@ -1,4 +1,4 @@
-const require_db = require('./db-B9jJgYNw.cjs');
+const require_db = require('./db-CEt1ZD2V.cjs');
 let kysely = require("kysely");
 
 //#region src/db/bun-sqlite-dialect.ts

package/dist/db/index.cjs

@@ -1,5 +1,5 @@
-const require_db = require('../db-B9jJgYNw.cjs');
-const require_neon_dialect = require('../neon-dialect-BBWePgOv.cjs');
+const require_db = require('../db-CEt1ZD2V.cjs');
+const require_neon_dialect = require('../neon-dialect-sUVNvVYh.cjs');
 
 exports.SCHEMA_METADATA = require_db.SCHEMA_METADATA;
 exports.configVariantsSchema = require_db.configVariantsSchema;
@@ -7,6 +7,7 @@ exports.configsSchema = require_db.configsSchema;
 exports.createDatabase = require_db.createDatabase;
 exports.createDatabaseFromConnection = require_db.createDatabaseFromConnection;
 exports.createNeonDialect = require_neon_dialect.createNeonDialect;
+exports.createNeonSqlFunction = require_db.createNeonSqlFunction;
 exports.datasetRecordsSchema = require_db.datasetRecordsSchema;
 exports.datasetVersionRecordsSchema = require_db.datasetVersionRecordsSchema;
 exports.datasetVersionsSchema = require_db.datasetVersionsSchema;
@@ -15,6 +16,7 @@ exports.detectDatabaseType = require_db.detectDatabaseType;
 exports.environmentSecretsSchema = require_db.environmentSecretsSchema;
 exports.environmentsSchema = require_db.environmentsSchema;
 exports.executeWithSchema = require_neon_dialect.executeWithSchema;
+exports.generatePostgresSchemaSQL = require_db.generatePostgresSchemaSQL;
 exports.getMigrations = require_db.getMigrations;
 exports.guardrailConfigsSchema = require_db.guardrailConfigsSchema;
 exports.llmRequestsSchema = require_db.llmRequestsSchema;
@@ -28,6 +30,7 @@ exports.playgroundsSchema = require_db.playgroundsSchema;
 exports.providerConfigsSchema = require_db.providerConfigsSchema;
 exports.providerGuardrailOverridesSchema = require_db.providerGuardrailOverridesSchema;
 exports.runAutoMigrations = require_db.runAutoMigrations;
+exports.runSchemaSQL = require_db.runSchemaSQL;
 exports.schemas = require_db.schemas;
 exports.targetingRulesSchema = require_db.targetingRulesSchema;
 exports.validatePartialTableData = require_db.validatePartialTableData;

package/dist/db/index.d.cts

@@ -1,2 +1,2 @@
-import { $ as SCHEMA_METADATA, A as DatasetsTable, At as variantsSchema, B as LLMRequest, C as Dataset, Ct as playgroundRunsSchema, D as DatasetVersionRecord, Dt as schemas, E as DatasetVersion, Et as providerGuardrailOverridesSchema, F as GuardrailConfig, G as PlaygroundResultsTable, H as Playground, I as GuardrailConfigsTable, J as PlaygroundsTable, K as PlaygroundRun, L as GuardrailResult, M as EnvironmentSecret, N as EnvironmentSecretsTable, O as DatasetVersionRecordsTable, Ot as targetingRulesSchema, P as EnvironmentsTable, Q as ProviderGuardrailOverridesTable, R as GuardrailResults, S as Database, St as playgroundResultsSchema, T as DatasetRecordsTable, Tt as providerConfigsSchema, U as PlaygroundColumn, V as LLMRequestsTable, W as PlaygroundResult, X as ProviderConfigsTable, Y as ProviderConfig, Z as ProviderGuardrailOverride, _ as validateTableData, _t as environmentSecretsSchema, a as createDatabaseFromConnection, at as Variant, b as ConfigVariantsTable, bt as llmRequestsSchema, c as executeWithSchema, ct as VariantsTable, d as getMigrations, dt as configVariantsSchema, et as Selectable, f as matchType, ft as configsSchema, g as validatePartialTableData, gt as datasetsSchema, h as parseTableData, ht as datasetVersionsSchema, i as createDatabase, it as Updateable, j as Environment, jt as workspaceSettingsSchema, k as DatasetVersionsTable, kt as variantVersionsSchema, l as MigrationOptions, lt as WorkspaceSettings, m as parsePartialTableData, mt as datasetVersionRecordsSchema, n as DatabaseOptions, nt as TargetingRule, o as detectDatabaseType, ot as VariantVersion, p as runAutoMigrations, pt as datasetRecordsSchema, q as PlaygroundRunsTable, r as DatabaseType, rt as TargetingRulesTable, s as createNeonDialect, st as VariantVersionsTable, t as DatabaseConnection, tt as TableName, u as MigrationResult, ut as WorkspaceSettingsTable, v as Config, vt as environmentsSchema, w as DatasetRecord, wt as playgroundsSchema, x as ConfigsTable, xt as playgroundColumnSchema, y as ConfigVariant, yt as guardrailConfigsSchema, z as Insertable } from "../index-BtSgIKup.cjs";
-export { Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Dataset, DatasetRecord, DatasetRecordsTable, DatasetVersion, DatasetVersionRecord, DatasetVersionRecordsTable, DatasetVersionsTable, DatasetsTable, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, GuardrailConfig, GuardrailConfigsTable, GuardrailResult, GuardrailResults, Insertable, LLMRequest, LLMRequestsTable, MigrationOptions, MigrationResult, Playground, PlaygroundColumn, PlaygroundResult, PlaygroundResultsTable, PlaygroundRun, PlaygroundRunsTable, PlaygroundsTable, ProviderConfig, ProviderConfigsTable, ProviderGuardrailOverride, ProviderGuardrailOverridesTable, SCHEMA_METADATA, Selectable, TableName, TargetingRule, TargetingRulesTable, Updateable, Variant, VariantVersion, VariantVersionsTable, VariantsTable, WorkspaceSettings, WorkspaceSettingsTable, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };
+import { $ as ProviderConfigsTable, A as DatasetVersionRecord, At as schemas, B as GuardrailResult, C as ConfigVariantsTable, Ct as llmRequestsSchema, D as DatasetRecord, Dt as playgroundsSchema, E as Dataset, Et as playgroundRunsSchema, F as EnvironmentSecret, G as Playground, H as Insertable, I as EnvironmentSecretsTable, J as PlaygroundResultsTable, K as PlaygroundColumn, L as EnvironmentsTable, M as DatasetVersionsTable, Mt as variantVersionsSchema, N as DatasetsTable, Nt as variantsSchema, O as DatasetRecordsTable, Ot as providerConfigsSchema, P as Environment, Pt as workspaceSettingsSchema, Q as ProviderConfig, R as GuardrailConfig, S as ConfigVariant, St as guardrailConfigsSchema, T as Database, Tt as playgroundResultsSchema, U as LLMRequest, V as GuardrailResults, W as LLMRequestsTable, X as PlaygroundRunsTable, Y as PlaygroundRun, Z as PlaygroundsTable, _ as validateTableData, _t as datasetVersionRecordsSchema, a as createDatabaseFromConnection, at as TargetingRule, b as runSchemaSQL, bt as environmentSecretsSchema, c as executeWithSchema, ct as Variant, d as getMigrations, dt as VariantsTable, et as ProviderGuardrailOverride, f as matchType, ft as WorkspaceSettings, g as validatePartialTableData, gt as datasetRecordsSchema, h as parseTableData, ht as configsSchema, i as createDatabase, it as TableName, j as DatasetVersionRecordsTable, jt as targetingRulesSchema, k as DatasetVersion, kt as providerGuardrailOverridesSchema, l as MigrationOptions, lt as VariantVersion, m as parsePartialTableData, mt as configVariantsSchema, n as DatabaseOptions, nt as SCHEMA_METADATA, o as detectDatabaseType, ot as TargetingRulesTable, p as runAutoMigrations, pt as WorkspaceSettingsTable, q as PlaygroundResult, r as DatabaseType, rt as Selectable, s as createNeonDialect, st as Updateable, t as DatabaseConnection, tt as ProviderGuardrailOverridesTable, u as MigrationResult, ut as VariantVersionsTable, v as createNeonSqlFunction, vt as datasetVersionsSchema, w as ConfigsTable, wt as playgroundColumnSchema, x as Config, xt as environmentsSchema, y as generatePostgresSchemaSQL, yt as datasetsSchema, z as GuardrailConfigsTable } from "../index-Bk_flDhH.cjs";
+export { Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Dataset, DatasetRecord, DatasetRecordsTable, DatasetVersion, DatasetVersionRecord, DatasetVersionRecordsTable, DatasetVersionsTable, DatasetsTable, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, GuardrailConfig, GuardrailConfigsTable, GuardrailResult, GuardrailResults, Insertable, LLMRequest, LLMRequestsTable, MigrationOptions, MigrationResult, Playground, PlaygroundColumn, PlaygroundResult, PlaygroundResultsTable, PlaygroundRun, PlaygroundRunsTable, PlaygroundsTable, ProviderConfig, ProviderConfigsTable, ProviderGuardrailOverride, ProviderGuardrailOverridesTable, SCHEMA_METADATA, Selectable, TableName, TargetingRule, TargetingRulesTable, Updateable, Variant, VariantVersion, VariantVersionsTable, VariantsTable, WorkspaceSettings, WorkspaceSettingsTable, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, createNeonSqlFunction, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, generatePostgresSchemaSQL, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, runSchemaSQL, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };

package/dist/db/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as SCHEMA_METADATA, A as DatasetsTable, At as variantsSchema, B as LLMRequest, C as Dataset, Ct as playgroundRunsSchema, D as DatasetVersionRecord, Dt as schemas, E as DatasetVersion, Et as providerGuardrailOverridesSchema, F as GuardrailConfig, G as PlaygroundResultsTable, H as Playground, I as GuardrailConfigsTable, J as PlaygroundsTable, K as PlaygroundRun, L as GuardrailResult, M as EnvironmentSecret, N as EnvironmentSecretsTable, O as DatasetVersionRecordsTable, Ot as targetingRulesSchema, P as EnvironmentsTable, Q as ProviderGuardrailOverridesTable, R as GuardrailResults, S as Database, St as playgroundResultsSchema, T as DatasetRecordsTable, Tt as providerConfigsSchema, U as PlaygroundColumn, V as LLMRequestsTable, W as PlaygroundResult, X as ProviderConfigsTable, Y as ProviderConfig, Z as ProviderGuardrailOverride, _ as validateTableData, _t as environmentSecretsSchema, a as createDatabaseFromConnection, at as Variant, b as ConfigVariantsTable, bt as llmRequestsSchema, c as executeWithSchema, ct as VariantsTable, d as getMigrations, dt as configVariantsSchema, et as Selectable, f as matchType, ft as configsSchema, g as validatePartialTableData, gt as datasetsSchema, h as parseTableData, ht as datasetVersionsSchema, i as createDatabase, it as Updateable, j as Environment, jt as workspaceSettingsSchema, k as DatasetVersionsTable, kt as variantVersionsSchema, l as MigrationOptions, lt as WorkspaceSettings, m as parsePartialTableData, mt as datasetVersionRecordsSchema, n as DatabaseOptions, nt as TargetingRule, o as detectDatabaseType, ot as VariantVersion, p as runAutoMigrations, pt as datasetRecordsSchema, q as PlaygroundRunsTable, r as DatabaseType, rt as TargetingRulesTable, s as createNeonDialect, st as VariantVersionsTable, t as DatabaseConnection, tt as TableName, u as MigrationResult, ut as WorkspaceSettingsTable, v as Config, vt as environmentsSchema, w as DatasetRecord, wt as playgroundsSchema, x as ConfigsTable, xt as playgroundColumnSchema, y as ConfigVariant, yt as guardrailConfigsSchema, z as Insertable } from "../index-LRmy4sz9.mjs";
-export { Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Dataset, DatasetRecord, DatasetRecordsTable, DatasetVersion, DatasetVersionRecord, DatasetVersionRecordsTable, DatasetVersionsTable, DatasetsTable, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, GuardrailConfig, GuardrailConfigsTable, GuardrailResult, GuardrailResults, Insertable, LLMRequest, LLMRequestsTable, MigrationOptions, MigrationResult, Playground, PlaygroundColumn, PlaygroundResult, PlaygroundResultsTable, PlaygroundRun, PlaygroundRunsTable, PlaygroundsTable, ProviderConfig, ProviderConfigsTable, ProviderGuardrailOverride, ProviderGuardrailOverridesTable, SCHEMA_METADATA, Selectable, TableName, TargetingRule, TargetingRulesTable, Updateable, Variant, VariantVersion, VariantVersionsTable, VariantsTable, WorkspaceSettings, WorkspaceSettingsTable, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };
+import { $ as ProviderConfigsTable, A as DatasetVersionRecord, At as schemas, B as GuardrailResult, C as ConfigVariantsTable, Ct as llmRequestsSchema, D as DatasetRecord, Dt as playgroundsSchema, E as Dataset, Et as playgroundRunsSchema, F as EnvironmentSecret, G as Playground, H as Insertable, I as EnvironmentSecretsTable, J as PlaygroundResultsTable, K as PlaygroundColumn, L as EnvironmentsTable, M as DatasetVersionsTable, Mt as variantVersionsSchema, N as DatasetsTable, Nt as variantsSchema, O as DatasetRecordsTable, Ot as providerConfigsSchema, P as Environment, Pt as workspaceSettingsSchema, Q as ProviderConfig, R as GuardrailConfig, S as ConfigVariant, St as guardrailConfigsSchema, T as Database, Tt as playgroundResultsSchema, U as LLMRequest, V as GuardrailResults, W as LLMRequestsTable, X as PlaygroundRunsTable, Y as PlaygroundRun, Z as PlaygroundsTable, _ as validateTableData, _t as datasetVersionRecordsSchema, a as createDatabaseFromConnection, at as TargetingRule, b as runSchemaSQL, bt as environmentSecretsSchema, c as executeWithSchema, ct as Variant, d as getMigrations, dt as VariantsTable, et as ProviderGuardrailOverride, f as matchType, ft as WorkspaceSettings, g as validatePartialTableData, gt as datasetRecordsSchema, h as parseTableData, ht as configsSchema, i as createDatabase, it as TableName, j as DatasetVersionRecordsTable, jt as targetingRulesSchema, k as DatasetVersion, kt as providerGuardrailOverridesSchema, l as MigrationOptions, lt as VariantVersion, m as parsePartialTableData, mt as configVariantsSchema, n as DatabaseOptions, nt as SCHEMA_METADATA, o as detectDatabaseType, ot as TargetingRulesTable, p as runAutoMigrations, pt as WorkspaceSettingsTable, q as PlaygroundResult, r as DatabaseType, rt as Selectable, s as createNeonDialect, st as Updateable, t as DatabaseConnection, tt as ProviderGuardrailOverridesTable, u as MigrationResult, ut as VariantVersionsTable, v as createNeonSqlFunction, vt as datasetVersionsSchema, w as ConfigsTable, wt as playgroundColumnSchema, x as Config, xt as environmentsSchema, y as generatePostgresSchemaSQL, yt as datasetsSchema, z as GuardrailConfigsTable } from "../index-BvrZuRon.mjs";
+export { Config, ConfigVariant, ConfigVariantsTable, ConfigsTable, Database, DatabaseConnection, DatabaseOptions, DatabaseType, Dataset, DatasetRecord, DatasetRecordsTable, DatasetVersion, DatasetVersionRecord, DatasetVersionRecordsTable, DatasetVersionsTable, DatasetsTable, Environment, EnvironmentSecret, EnvironmentSecretsTable, EnvironmentsTable, GuardrailConfig, GuardrailConfigsTable, GuardrailResult, GuardrailResults, Insertable, LLMRequest, LLMRequestsTable, MigrationOptions, MigrationResult, Playground, PlaygroundColumn, PlaygroundResult, PlaygroundResultsTable, PlaygroundRun, PlaygroundRunsTable, PlaygroundsTable, ProviderConfig, ProviderConfigsTable, ProviderGuardrailOverride, ProviderGuardrailOverridesTable, SCHEMA_METADATA, Selectable, TableName, TargetingRule, TargetingRulesTable, Updateable, Variant, VariantVersion, VariantVersionsTable, VariantsTable, WorkspaceSettings, WorkspaceSettingsTable, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, createNeonSqlFunction, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, generatePostgresSchemaSQL, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, runSchemaSQL, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };

package/dist/db/index.mjs

@@ -1,4 +1,4 @@
-import { A as schemas, C as llmRequestsSchema, D as playgroundsSchema, E as playgroundRunsSchema, M as variantVersionsSchema, N as variantsSchema, O as providerConfigsSchema, P as workspaceSettingsSchema, S as guardrailConfigsSchema, T as playgroundResultsSchema, _ as datasetVersionRecordsSchema, a as matchType, b as environmentSecretsSchema, d as validatePartialTableData, f as validateTableData, g as datasetRecordsSchema, h as configsSchema, i as getMigrations, j as targetingRulesSchema, k as providerGuardrailOverridesSchema, l as parsePartialTableData, m as configVariantsSchema, n as createDatabaseFromConnection, o as runAutoMigrations, p as SCHEMA_METADATA, r as detectDatabaseType, t as createDatabase, u as parseTableData, v as datasetVersionsSchema, w as playgroundColumnSchema, x as environmentsSchema, y as datasetsSchema } from "../db-DX_QaIkx.mjs";
+import { A as playgroundsSchema, C as environmentSecretsSchema, D as playgroundColumnSchema, E as llmRequestsSchema, F as variantVersionsSchema, I as variantsSchema, L as workspaceSettingsSchema, M as providerGuardrailOverridesSchema, N as schemas, O as playgroundResultsSchema, P as targetingRulesSchema, S as datasetsSchema, T as guardrailConfigsSchema, _ as configVariantsSchema, a as matchType, b as datasetVersionRecordsSchema, d as validatePartialTableData, f as validateTableData, g as SCHEMA_METADATA, h as runSchemaSQL, i as getMigrations, j as providerConfigsSchema, k as playgroundRunsSchema, l as parsePartialTableData, m as generatePostgresSchemaSQL, n as createDatabaseFromConnection, o as runAutoMigrations, p as createNeonSqlFunction, r as detectDatabaseType, t as createDatabase, u as parseTableData, v as configsSchema, w as environmentsSchema, x as datasetVersionsSchema, y as datasetRecordsSchema } from "../db-BN99c_b5.mjs";
 import { n as executeWithSchema, t as createNeonDialect } from "../neon-dialect-DySGBYUi.mjs";
 
-export { SCHEMA_METADATA, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };
+export { SCHEMA_METADATA, configVariantsSchema, configsSchema, createDatabase, createDatabaseFromConnection, createNeonDialect, createNeonSqlFunction, datasetRecordsSchema, datasetVersionRecordsSchema, datasetVersionsSchema, datasetsSchema, detectDatabaseType, environmentSecretsSchema, environmentsSchema, executeWithSchema, generatePostgresSchemaSQL, getMigrations, guardrailConfigsSchema, llmRequestsSchema, matchType, parsePartialTableData, parseTableData, playgroundColumnSchema, playgroundResultsSchema, playgroundRunsSchema, playgroundsSchema, providerConfigsSchema, providerGuardrailOverridesSchema, runAutoMigrations, runSchemaSQL, schemas, targetingRulesSchema, validatePartialTableData, validateTableData, variantVersionsSchema, variantsSchema, workspaceSettingsSchema };

package/dist/{db-DX_QaIkx.mjs → db-BN99c_b5.mjs}

@@ -13915,6 +13915,230 @@ const schemas = {
 	llm_requests: llmRequestsSchema
 };
 
+//#endregion
+//#region src/db/schema-sql.ts
+/**
+* Idempotent SQL Schema Generator
+*
+* Generates fully idempotent PostgreSQL schema SQL that can be run on every
+* server restart. Works in edge environments (no file system access needed).
+*
+* This is the programmatic version of the generate-schema-sql.ts script.
+*/
+function toSnakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function getDefaultValue(fieldType, defaultValue) {
+	if (defaultValue === void 0) return null;
+	if (defaultValue === "now()") return "NOW()";
+	if (typeof defaultValue === "boolean") return defaultValue ? "TRUE" : "FALSE";
+	if (typeof defaultValue === "number") return String(defaultValue);
+	if (typeof defaultValue === "string") {
+		if (defaultValue === "{}") return "'{}'::jsonb";
+		return `'${defaultValue}'`;
+	}
+	return null;
+}
+const TYPE_MAPPINGS = {
+	uuid: "UUID",
+	text: "TEXT",
+	integer: "INTEGER",
+	boolean: "BOOLEAN",
+	timestamp: "TIMESTAMP WITH TIME ZONE",
+	jsonb: "JSONB"
+};
+/**
+* Generate idempotent PostgreSQL schema SQL
+*
+* @param schemaName - Optional PostgreSQL schema name (e.g., 'llmops').
+*                     If not provided, tables are created in the current search_path.
+* @returns SQL string that can be executed to create/update the schema
+*/
+function generatePostgresSchemaSQL(schemaName) {
+	const lines = [];
+	const schemaPrefix = schemaName ? `"${schemaName}".` : "";
+	lines.push(`-- LLMOps Database Schema (PostgreSQL)`);
+	lines.push(`-- This SQL is fully idempotent and safe to run on every server restart.`);
+	lines.push("");
+	if (schemaName) {
+		lines.push(`-- Create schema if not exists`);
+		lines.push(`CREATE SCHEMA IF NOT EXISTS "${schemaName}";`);
+		lines.push("");
+	}
+	lines.push(`-- Enable UUID extension`);
+	lines.push(`CREATE EXTENSION IF NOT EXISTS "pgcrypto" SCHEMA public;`);
+	lines.push("");
+	const sortedTables = Object.entries(SCHEMA_METADATA.tables).map(([name, meta$2]) => ({
+		name,
+		meta: meta$2
+	})).sort((a, b) => a.meta.order - b.meta.order);
+	lines.push(`-- STEP 1: Create tables (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const fullTableName = schemaPrefix + toSnakeCase(name);
+		if (!Object.entries(meta$2.fields).find(([_, f]) => f.primaryKey)) continue;
+		lines.push(`CREATE TABLE IF NOT EXISTS ${fullTableName} (`);
+		lines.push(`  id UUID PRIMARY KEY DEFAULT gen_random_uuid()`);
+		lines.push(`);`);
+	}
+	lines.push("");
+	lines.push(`-- STEP 2: Add columns (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const fullTableName = schemaPrefix + toSnakeCase(name);
+		for (const [columnName, field] of Object.entries(meta$2.fields)) {
+			if (field.primaryKey) continue;
+			const snakeColumn = toSnakeCase(columnName);
+			const sqlType = TYPE_MAPPINGS[field.type] || "TEXT";
+			const defaultVal = getDefaultValue(field.type, field.default);
+			let colDef = `${snakeColumn} ${sqlType}`;
+			if (defaultVal) colDef += ` DEFAULT ${defaultVal}`;
+			lines.push(`ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS ${colDef};`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 3: Add unique constraints (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.unique) {
+			const snakeColumn = toSnakeCase(columnName);
+			const constraintName = `uq_${snakeTable}_${snakeColumn}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${snakeColumn});`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+		if (meta$2.uniqueConstraints) for (const constraint of meta$2.uniqueConstraints) {
+			const cols = constraint.columns.map(toSnakeCase).join(", ");
+			const constraintName = `uq_${snakeTable}_${constraint.columns.map(toSnakeCase).join("_")}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols});`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 4: Add foreign keys (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
+			const snakeColumn = toSnakeCase(columnName);
+			const refTable = schemaPrefix + toSnakeCase(field.references.table);
+			const refColumn = toSnakeCase(field.references.column);
+			const constraintName = `fk_${snakeTable}_${snakeColumn}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName}`);
+			lines.push(`      FOREIGN KEY (${snakeColumn}) REFERENCES ${refTable}(${refColumn}) ON DELETE CASCADE;`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 5: Create indexes (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
+			const snakeColumn = toSnakeCase(columnName);
+			lines.push(`CREATE INDEX IF NOT EXISTS idx_${snakeTable}_${snakeColumn} ON ${fullTableName}(${snakeColumn});`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 6: Create updated_at triggers`);
+	const functionName = `${schemaName ? `"${schemaName}".` : "public."}update_updated_at_column`;
+	lines.push(`CREATE OR REPLACE FUNCTION ${functionName}()`);
+	lines.push(`RETURNS TRIGGER AS $$`);
+	lines.push(`BEGIN`);
+	lines.push(`  NEW.updated_at = NOW();`);
+	lines.push(`  RETURN NEW;`);
+	lines.push(`END;`);
+	lines.push(`$$ language 'plpgsql';`);
+	for (const { name } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		lines.push(`DROP TRIGGER IF EXISTS update_${snakeTable}_updated_at ON ${fullTableName};`);
+		lines.push(`CREATE TRIGGER update_${snakeTable}_updated_at BEFORE UPDATE ON ${fullTableName} FOR EACH ROW EXECUTE FUNCTION ${functionName}();`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Execute the schema SQL using a Neon SQL function
+*
+* @param sql - Neon sql function (from `neon()` or passed connection)
+* @param schemaName - Optional PostgreSQL schema name
+*/
+async function runSchemaSQL(sql$1, schemaName) {
+	const statements = splitSQLStatements(generatePostgresSchemaSQL(schemaName));
+	for (const statement of statements) {
+		const trimmed = statement.trim();
+		if (trimmed && !trimmed.startsWith("--")) await sql$1(trimmed);
+	}
+}
+/**
+* Split SQL into individual statements, keeping DO blocks together
+*/
+function splitSQLStatements(sql$1) {
+	const statements = [];
+	let current = "";
+	let inDoBlock = false;
+	const lines = sql$1.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("--")) continue;
+		if (trimmed === "DO $$") {
+			inDoBlock = true;
+			current = line + "\n";
+			continue;
+		}
+		if (inDoBlock) {
+			current += line + "\n";
+			if (trimmed === "END $$;") {
+				statements.push(current.trim());
+				current = "";
+				inDoBlock = false;
+			}
+			continue;
+		}
+		current += line + "\n";
+		if (trimmed.endsWith(";")) {
+			statements.push(current.trim());
+			current = "";
+		}
+	}
+	if (current.trim()) statements.push(current.trim());
+	return statements;
+}
+/**
+* Create a Neon SQL function from various connection types
+*
+* @param rawConnection - neon() function, connection string, or undefined (uses env vars)
+* @returns SQL function that can be used with runSchemaSQL, or null if unable to create
+*/
+async function createNeonSqlFunction(rawConnection) {
+	if (typeof rawConnection === "function") return rawConnection;
+	if (typeof rawConnection === "string" && rawConnection) {
+		const { neon: neon$1 } = await import("@neondatabase/serverless");
+		return neon$1(rawConnection);
+	}
+	const connectionString = process.env.NEON_CONNECTION_STRING || process.env.NEON_PG_URL || process.env.DATABASE_URL || process.env.POSTGRES_URL || "";
+	if (!connectionString) return null;
+	const { neon } = await import("@neondatabase/serverless");
+	return neon(connectionString);
+}
+
 //#endregion
 //#region src/db/validation.ts
 /**
@@ -14416,4 +14640,4 @@ async function createDatabaseFromConnection(rawConnection, options) {
 }
 
 //#endregion
-export { schemas as A, literal as B, llmRequestsSchema as C, playgroundsSchema as D, playgroundRunsSchema as E, zod_default as F, union as G, object as H, _enum as I, unknown as K, any as L, variantVersionsSchema as M, variantsSchema as N, providerConfigsSchema as O, workspaceSettingsSchema as P, array as R, guardrailConfigsSchema as S, playgroundResultsSchema as T, record as U, number$1 as V, string$1 as W, datasetVersionRecordsSchema as _, matchType as a, environmentSecretsSchema as b, logger as c, validatePartialTableData as d, validateTableData as f, datasetRecordsSchema as g, configsSchema as h, getMigrations$1 as i, targetingRulesSchema as j, providerGuardrailOverridesSchema as k, parsePartialTableData as l, configVariantsSchema as m, createDatabaseFromConnection as n, runAutoMigrations as o, SCHEMA_METADATA as p, detectDatabaseType as r, getAuthClientOptions as s, createDatabase as t, parseTableData as u, datasetVersionsSchema as v, playgroundColumnSchema as w, environmentsSchema as x, datasetsSchema as y, boolean$1 as z };
+export { playgroundsSchema as A, any as B, environmentSecretsSchema as C, playgroundColumnSchema as D, llmRequestsSchema as E, variantVersionsSchema as F, object as G, boolean$1 as H, variantsSchema as I, union as J, record as K, workspaceSettingsSchema as L, providerGuardrailOverridesSchema as M, schemas as N, playgroundResultsSchema as O, targetingRulesSchema as P, zod_default as R, datasetsSchema as S, guardrailConfigsSchema as T, literal as U, array as V, number$1 as W, unknown as Y, configVariantsSchema as _, matchType as a, datasetVersionRecordsSchema as b, logger as c, validatePartialTableData as d, validateTableData as f, SCHEMA_METADATA as g, runSchemaSQL as h, getMigrations$1 as i, providerConfigsSchema as j, playgroundRunsSchema as k, parsePartialTableData as l, generatePostgresSchemaSQL as m, createDatabaseFromConnection as n, runAutoMigrations as o, createNeonSqlFunction as p, string$1 as q, detectDatabaseType as r, getAuthClientOptions as s, createDatabase as t, parseTableData as u, configsSchema as v, environmentsSchema as w, datasetVersionsSchema as x, datasetRecordsSchema as y, _enum as z };

package/dist/{db-B9jJgYNw.cjs → db-CEt1ZD2V.cjs}

@@ -13939,6 +13939,230 @@ const schemas = {
 	llm_requests: llmRequestsSchema
 };
 
+//#endregion
+//#region src/db/schema-sql.ts
+/**
+* Idempotent SQL Schema Generator
+*
+* Generates fully idempotent PostgreSQL schema SQL that can be run on every
+* server restart. Works in edge environments (no file system access needed).
+*
+* This is the programmatic version of the generate-schema-sql.ts script.
+*/
+function toSnakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function getDefaultValue(fieldType, defaultValue) {
+	if (defaultValue === void 0) return null;
+	if (defaultValue === "now()") return "NOW()";
+	if (typeof defaultValue === "boolean") return defaultValue ? "TRUE" : "FALSE";
+	if (typeof defaultValue === "number") return String(defaultValue);
+	if (typeof defaultValue === "string") {
+		if (defaultValue === "{}") return "'{}'::jsonb";
+		return `'${defaultValue}'`;
+	}
+	return null;
+}
+const TYPE_MAPPINGS = {
+	uuid: "UUID",
+	text: "TEXT",
+	integer: "INTEGER",
+	boolean: "BOOLEAN",
+	timestamp: "TIMESTAMP WITH TIME ZONE",
+	jsonb: "JSONB"
+};
+/**
+* Generate idempotent PostgreSQL schema SQL
+*
+* @param schemaName - Optional PostgreSQL schema name (e.g., 'llmops').
+*                     If not provided, tables are created in the current search_path.
+* @returns SQL string that can be executed to create/update the schema
+*/
+function generatePostgresSchemaSQL(schemaName) {
+	const lines = [];
+	const schemaPrefix = schemaName ? `"${schemaName}".` : "";
+	lines.push(`-- LLMOps Database Schema (PostgreSQL)`);
+	lines.push(`-- This SQL is fully idempotent and safe to run on every server restart.`);
+	lines.push("");
+	if (schemaName) {
+		lines.push(`-- Create schema if not exists`);
+		lines.push(`CREATE SCHEMA IF NOT EXISTS "${schemaName}";`);
+		lines.push("");
+	}
+	lines.push(`-- Enable UUID extension`);
+	lines.push(`CREATE EXTENSION IF NOT EXISTS "pgcrypto" SCHEMA public;`);
+	lines.push("");
+	const sortedTables = Object.entries(SCHEMA_METADATA.tables).map(([name, meta$2]) => ({
+		name,
+		meta: meta$2
+	})).sort((a, b) => a.meta.order - b.meta.order);
+	lines.push(`-- STEP 1: Create tables (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const fullTableName = schemaPrefix + toSnakeCase(name);
+		if (!Object.entries(meta$2.fields).find(([_, f]) => f.primaryKey)) continue;
+		lines.push(`CREATE TABLE IF NOT EXISTS ${fullTableName} (`);
+		lines.push(`  id UUID PRIMARY KEY DEFAULT gen_random_uuid()`);
+		lines.push(`);`);
+	}
+	lines.push("");
+	lines.push(`-- STEP 2: Add columns (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const fullTableName = schemaPrefix + toSnakeCase(name);
+		for (const [columnName, field] of Object.entries(meta$2.fields)) {
+			if (field.primaryKey) continue;
+			const snakeColumn = toSnakeCase(columnName);
+			const sqlType = TYPE_MAPPINGS[field.type] || "TEXT";
+			const defaultVal = getDefaultValue(field.type, field.default);
+			let colDef = `${snakeColumn} ${sqlType}`;
+			if (defaultVal) colDef += ` DEFAULT ${defaultVal}`;
+			lines.push(`ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS ${colDef};`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 3: Add unique constraints (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.unique) {
+			const snakeColumn = toSnakeCase(columnName);
+			const constraintName = `uq_${snakeTable}_${snakeColumn}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${snakeColumn});`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+		if (meta$2.uniqueConstraints) for (const constraint of meta$2.uniqueConstraints) {
+			const cols = constraint.columns.map(toSnakeCase).join(", ");
+			const constraintName = `uq_${snakeTable}_${constraint.columns.map(toSnakeCase).join("_")}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols});`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 4: Add foreign keys (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
+			const snakeColumn = toSnakeCase(columnName);
+			const refTable = schemaPrefix + toSnakeCase(field.references.table);
+			const refColumn = toSnakeCase(field.references.column);
+			const constraintName = `fk_${snakeTable}_${snakeColumn}`;
+			lines.push(`DO $$`);
+			lines.push(`BEGIN`);
+			lines.push(`  IF NOT EXISTS (`);
+			lines.push(`    SELECT 1 FROM pg_constraint WHERE conname = '${constraintName}'`);
+			lines.push(`  ) THEN`);
+			lines.push(`    ALTER TABLE ${fullTableName} ADD CONSTRAINT ${constraintName}`);
+			lines.push(`      FOREIGN KEY (${snakeColumn}) REFERENCES ${refTable}(${refColumn}) ON DELETE CASCADE;`);
+			lines.push(`  END IF;`);
+			lines.push(`END $$;`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 5: Create indexes (if not exist)`);
+	for (const { name, meta: meta$2 } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		for (const [columnName, field] of Object.entries(meta$2.fields)) if (field.references) {
+			const snakeColumn = toSnakeCase(columnName);
+			lines.push(`CREATE INDEX IF NOT EXISTS idx_${snakeTable}_${snakeColumn} ON ${fullTableName}(${snakeColumn});`);
+		}
+	}
+	lines.push("");
+	lines.push(`-- STEP 6: Create updated_at triggers`);
+	const functionName = `${schemaName ? `"${schemaName}".` : "public."}update_updated_at_column`;
+	lines.push(`CREATE OR REPLACE FUNCTION ${functionName}()`);
+	lines.push(`RETURNS TRIGGER AS $$`);
+	lines.push(`BEGIN`);
+	lines.push(`  NEW.updated_at = NOW();`);
+	lines.push(`  RETURN NEW;`);
+	lines.push(`END;`);
+	lines.push(`$$ language 'plpgsql';`);
+	for (const { name } of sortedTables) {
+		const snakeTable = toSnakeCase(name);
+		const fullTableName = schemaPrefix + snakeTable;
+		lines.push(`DROP TRIGGER IF EXISTS update_${snakeTable}_updated_at ON ${fullTableName};`);
+		lines.push(`CREATE TRIGGER update_${snakeTable}_updated_at BEFORE UPDATE ON ${fullTableName} FOR EACH ROW EXECUTE FUNCTION ${functionName}();`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Execute the schema SQL using a Neon SQL function
+*
+* @param sql - Neon sql function (from `neon()` or passed connection)
+* @param schemaName - Optional PostgreSQL schema name
+*/
+async function runSchemaSQL(sql$1, schemaName) {
+	const statements = splitSQLStatements(generatePostgresSchemaSQL(schemaName));
+	for (const statement of statements) {
+		const trimmed = statement.trim();
+		if (trimmed && !trimmed.startsWith("--")) await sql$1(trimmed);
+	}
+}
+/**
+* Split SQL into individual statements, keeping DO blocks together
+*/
+function splitSQLStatements(sql$1) {
+	const statements = [];
+	let current = "";
+	let inDoBlock = false;
+	const lines = sql$1.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("--")) continue;
+		if (trimmed === "DO $$") {
+			inDoBlock = true;
+			current = line + "\n";
+			continue;
+		}
+		if (inDoBlock) {
+			current += line + "\n";
+			if (trimmed === "END $$;") {
+				statements.push(current.trim());
+				current = "";
+				inDoBlock = false;
+			}
+			continue;
+		}
+		current += line + "\n";
+		if (trimmed.endsWith(";")) {
+			statements.push(current.trim());
+			current = "";
+		}
+	}
+	if (current.trim()) statements.push(current.trim());
+	return statements;
+}
+/**
+* Create a Neon SQL function from various connection types
+*
+* @param rawConnection - neon() function, connection string, or undefined (uses env vars)
+* @returns SQL function that can be used with runSchemaSQL, or null if unable to create
+*/
+async function createNeonSqlFunction(rawConnection) {
+	if (typeof rawConnection === "function") return rawConnection;
+	if (typeof rawConnection === "string" && rawConnection) {
+		const { neon: neon$1 } = await import("@neondatabase/serverless");
+		return neon$1(rawConnection);
+	}
+	const connectionString = process.env.NEON_CONNECTION_STRING || process.env.NEON_PG_URL || process.env.DATABASE_URL || process.env.POSTGRES_URL || "";
+	if (!connectionString) return null;
+	const { neon } = await import("@neondatabase/serverless");
+	return neon(connectionString);
+}
+
 //#endregion
 //#region src/db/validation.ts
 /**
@@ -14397,12 +14621,12 @@ async function createDatabaseFromConnection(rawConnection, options) {
 		case "sqlite":
 			if ("aggregate" in rawConnection && !("createSession" in rawConnection)) dialect = new kysely.SqliteDialect({ database: rawConnection });
 			else if ("fileControl" in rawConnection) {
-				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-DQa87s1D.cjs"));
+				const { BunSqliteDialect } = await Promise.resolve().then(() => require("./bun-sqlite-dialect-lNniX_lj.cjs"));
 				dialect = new BunSqliteDialect({ database: rawConnection });
 			} else if ("createSession" in rawConnection && typeof window === "undefined") try {
 				const { DatabaseSync } = await import("node:sqlite");
 				if (rawConnection instanceof DatabaseSync) {
-					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-DLKHH0RE.cjs"));
+					const { NodeSqliteDialect } = await Promise.resolve().then(() => require("./node-sqlite-dialect-BPGejxOC.cjs"));
 					dialect = new NodeSqliteDialect({ database: rawConnection });
 				}
 			} catch {}
@@ -14420,7 +14644,7 @@ async function createDatabaseFromConnection(rawConnection, options) {
 			break;
 		case "neon": {
 			if (typeof rawConnection === "function") {
-				const { createNeonDialect: createNeonDialect$1 } = await Promise.resolve().then(() => require("./neon-dialect-BBGTCnek.cjs"));
+				const { createNeonDialect: createNeonDialect$1 } = await Promise.resolve().then(() => require("./neon-dialect-C9_0GrsB.cjs"));
 				dialect = createNeonDialect$1(rawConnection);
 				break;
 			}
@@ -14428,7 +14652,7 @@ async function createDatabaseFromConnection(rawConnection, options) {
 			if (!connectionString) throw new Error("Neon connection string is required. Pass it directly as the database option or set one of: NEON_CONNECTION_STRING, NEON_PG_URL, DATABASE_URL, POSTGRES_URL");
 			const { neon } = await import("@neondatabase/serverless");
 			const sql$1 = neon(connectionString);
-			const { createNeonDialect } = await Promise.resolve().then(() => require("./neon-dialect-BBGTCnek.cjs"));
+			const { createNeonDialect } = await Promise.resolve().then(() => require("./neon-dialect-C9_0GrsB.cjs"));
 			dialect = createNeonDialect(sql$1);
 			break;
 		}
@@ -14500,6 +14724,12 @@ Object.defineProperty(exports, 'createDatabaseFromConnection', {
     return createDatabaseFromConnection;
   }
 });
+Object.defineProperty(exports, 'createNeonSqlFunction', {
+  enumerable: true,
+  get: function () {
+    return createNeonSqlFunction;
+  }
+});
 Object.defineProperty(exports, 'datasetRecordsSchema', {
   enumerable: true,
   get: function () {
@@ -14542,6 +14772,12 @@ Object.defineProperty(exports, 'environmentsSchema', {
     return environmentsSchema;
   }
 });
+Object.defineProperty(exports, 'generatePostgresSchemaSQL', {
+  enumerable: true,
+  get: function () {
+    return generatePostgresSchemaSQL;
+  }
+});
 Object.defineProperty(exports, 'getAuthClientOptions', {
   enumerable: true,
   get: function () {
@@ -14656,6 +14892,12 @@ Object.defineProperty(exports, 'runAutoMigrations', {
     return runAutoMigrations;
   }
 });
+Object.defineProperty(exports, 'runSchemaSQL', {
+  enumerable: true,
+  get: function () {
+    return runSchemaSQL;
+  }
+});
 Object.defineProperty(exports, 'schemas', {
   enumerable: true,
   get: function () {