@prisma-next/adapter-postgres 0.5.0-dev.9 → 0.5.1

package/dist/descriptor-meta-CyjnYUWG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CyjnYUWG.mjs","names":[],"sources":["../src/core/enum-control-hooks.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport { arraysEqual } from '@prisma-next/family-sql/schema-verify';\nimport type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { PG_ENUM_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';\nimport {\n  escapeLiteral,\n  qualifyName,\n  quoteIdentifier,\n  validateEnumValueLength,\n} from '@prisma-next/target-postgres/sql-utils';\n\n/**\n * Postgres enum control hooks.\n *\n * - Plans enum type operations for migrations\n * - Verifies enum types in schema IR\n * - Introspects enum types from the database\n */\ntype EnumRow = {\n  schema_name: string;\n  type_name: string;\n  values: string[];\n};\n\ntype EnumDiff =\n  | { kind: 'unchanged' }\n  | { kind: 'add_values'; values: readonly string[] }\n  | { kind: 'rebuild'; removedValues: readonly string[] };\n\n// ============================================================================\n// Introspection SQL\n// ============================================================================\n\nconst ENUM_INTROSPECT_QUERY = `\n  SELECT\n    n.nspname AS schema_name,\n    t.typname AS type_name,\n    array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values\n  FROM pg_type t\n  JOIN pg_namespace n ON t.typnamespace = n.oid\n  JOIN pg_enum e ON t.oid = e.enumtypid\n  WHERE n.nspname = $1\n  GROUP BY n.nspname, t.typname\n  ORDER BY n.nspname, t.typname\n`;\n\n// ============================================================================\n// Schema Helpers (Simplified)\n// ============================================================================\n\n/**\n * Type guard for string arrays. Used for runtime validation of introspected data.\n */\nfunction isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every((entry) => typeof entry === 'string');\n}\n\n/**\n * Parses a PostgreSQL array value into a JavaScript string array.\n *\n * PostgreSQL's `pg` library may return `array_agg` results either as:\n * - A JavaScript array (when type parsers are configured)\n * - A string in PostgreSQL array literal format: `{value1,value2,...}`\n *\n * Handles PostgreSQL's quoting rules for array elements:\n * - Elements containing commas, double quotes, backslashes, or whitespace are double-quoted\n * - Inside quoted elements, `\\\"` represents `\"` and `\\\\` represents `\\`\n *\n * @param value - The value to parse (array or PostgreSQL array string)\n * @returns A string array, or null if the value cannot be parsed\n */\nexport function parsePostgresArray(value: unknown): string[] | null {\n  if (isStringArray(value)) {\n    return value;\n  }\n  if (typeof value === 'string' && value.startsWith('{') && value.endsWith('}')) {\n    const inner = value.slice(1, -1);\n    if (inner === '') {\n      return [];\n    }\n    return parseArrayElements(inner);\n  }\n  return null;\n}\n\nfunction parseArrayElements(input: string): string[] {\n  const result: string[] = [];\n  let i = 0;\n  while (i < input.length) {\n    if (input[i] === ',') {\n      i++;\n      continue;\n    }\n    if (input[i] === '\"') {\n      i++;\n      let element = '';\n      while (i < input.length && input[i] !== '\"') {\n        if (input[i] === '\\\\' && i + 1 < input.length) {\n          i++;\n          element += input[i];\n        } else {\n          element += input[i];\n        }\n        i++;\n      }\n      i++;\n      result.push(element);\n    } else {\n      const nextComma = input.indexOf(',', i);\n      if (nextComma === -1) {\n        result.push(input.slice(i).trim());\n        i = input.length;\n      } else {\n        result.push(input.slice(i, nextComma).trim());\n        i = nextComma;\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Extracts enum values from a StorageTypeInstance.\n * Returns null if values are missing or invalid.\n */\nfunction getEnumValues(typeInstance: StorageTypeInstance): readonly string[] | null {\n  const values = typeInstance.typeParams?.['values'];\n  return isStringArray(values) ? values : null;\n}\n\n/**\n * Reads existing enum values from the schema IR for a given native type.\n * Uses optional chaining to simplify navigation through the annotations structure.\n */\nfunction readExistingEnumValues(schema: SqlSchemaIR, nativeType: string): readonly string[] | null {\n  const storageTypes = (schema.annotations?.['pg'] as Record<string, unknown> | undefined)?.[\n    'storageTypes'\n  ] as Record<string, StorageTypeInstance> | undefined;\n\n  const existing = storageTypes?.[nativeType];\n  if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {\n    return null;\n  }\n  return getEnumValues(existing);\n}\n\n/**\n * Determines what changes are needed to transform existing enum values to desired values.\n *\n * Returns one of:\n * - `unchanged`: No changes needed, values match exactly\n * - `add_values`: New values can be safely appended (PostgreSQL supports this)\n * - `rebuild`: Full enum rebuild required (value removal, reordering, or both)\n *\n * Note: PostgreSQL enums can only have values added (not removed or reordered) without\n * a full type rebuild involving temp type creation and column migration.\n *\n * @param existing - Current enum values in the database\n * @param desired - Target enum values from the contract\n * @returns The type of change required\n */\nfunction determineEnumDiff(existing: readonly string[], desired: readonly string[]): EnumDiff {\n  if (arraysEqual(existing, desired)) {\n    return { kind: 'unchanged' };\n  }\n\n  // Use Sets for O(1) lookups instead of O(n) array.includes()\n  const existingSet = new Set(existing);\n  const desiredSet = new Set(desired);\n\n  const missingValues = desired.filter((value) => !existingSet.has(value));\n  const removedValues = existing.filter((value) => !desiredSet.has(value));\n  const orderMismatch =\n    missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);\n\n  if (removedValues.length > 0 || orderMismatch) {\n    return { kind: 'rebuild', removedValues };\n  }\n\n  return { kind: 'add_values', values: missingValues };\n}\n\n// ============================================================================\n// SQL Helpers\n// ============================================================================\n\nfunction enumTypeExistsCheck(schemaName: string, typeName: string, exists = true): string {\n  const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';\n  return `SELECT ${existsClause} (\n  SELECT 1\n  FROM pg_type t\n  JOIN pg_namespace n ON t.typnamespace = n.oid\n  WHERE n.nspname = '${escapeLiteral(schemaName)}'\n    AND t.typname = '${escapeLiteral(typeName)}'\n)`;\n}\n\n// ============================================================================\n// Operation Builders\n// ============================================================================\n\nfunction buildCreateEnumOperation(\n  typeName: string,\n  nativeType: string,\n  schemaName: string,\n  values: readonly string[],\n): SqlMigrationPlanOperation<unknown> {\n  // Validate all enum values don't exceed PostgreSQL's label length limit\n  for (const value of values) {\n    validateEnumValueLength(value, typeName);\n  }\n  const literalValues = values.map((value) => `'${escapeLiteral(value)}'`).join(', ');\n  const qualifiedType = qualifyName(schemaName, nativeType);\n  return {\n    id: `type.${typeName}`,\n    label: `Create type ${typeName}`,\n    summary: `Creates enum type ${typeName}`,\n    operationClass: 'additive',\n    target: { id: 'postgres' },\n    precheck: [\n      {\n        description: `ensure type \"${nativeType}\" does not exist`,\n        sql: enumTypeExistsCheck(schemaName, nativeType, false),\n      },\n    ],\n    execute: [\n      {\n        description: `create type \"${nativeType}\"`,\n        sql: `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`,\n      },\n    ],\n    postcheck: [\n      {\n        description: `verify type \"${nativeType}\" exists`,\n        sql: enumTypeExistsCheck(schemaName, nativeType),\n      },\n    ],\n  };\n}\n\n/**\n * Computes the optimal position for inserting a new enum value to maintain\n * the desired order relative to existing values.\n *\n * PostgreSQL's `ALTER TYPE ADD VALUE` supports BEFORE/AFTER positioning.\n * This function finds the best reference value by:\n * 1. Looking for the nearest preceding value that already exists\n * 2. Falling back to the nearest following value if no preceding exists\n * 3. Defaulting to end-of-list if no reference is found\n *\n * @param options.desired - The target ordered list of all enum values\n * @param options.desiredIndex - Index of the value being inserted in the desired list\n * @param options.current - Current list of enum values (being built up incrementally)\n * @returns SQL clause (e.g., \" AFTER 'x'\") and insert position for tracking\n */\nfunction computeInsertPosition(options: {\n  desired: readonly string[];\n  desiredIndex: number;\n  current: readonly string[];\n}): { clause: string; insertAt: number } {\n  const { desired, desiredIndex, current } = options;\n  const currentSet = new Set(current);\n  const previous = desired\n    .slice(0, desiredIndex)\n    .reverse()\n    .find((candidate) => currentSet.has(candidate));\n  const next = desired.slice(desiredIndex + 1).find((candidate) => currentSet.has(candidate));\n  const clause = previous\n    ? ` AFTER '${escapeLiteral(previous)}'`\n    : next\n      ? ` BEFORE '${escapeLiteral(next)}'`\n      : '';\n  const insertAt = previous\n    ? current.indexOf(previous) + 1\n    : next\n      ? current.indexOf(next)\n      : current.length;\n\n  return { clause, insertAt };\n}\n\n/**\n * Builds operations to add new enum values to an existing PostgreSQL enum type.\n *\n * Each new value is added with `ALTER TYPE ... ADD VALUE IF NOT EXISTS` for idempotency.\n * Values are inserted in the correct order using BEFORE/AFTER positioning to match\n * the desired final order.\n *\n * This is a safe, non-destructive operation - existing data is not affected.\n *\n * @param options.typeName - Contract-level type name (e.g., 'Role')\n * @param options.nativeType - PostgreSQL type name (e.g., 'role')\n * @param options.schemaName - PostgreSQL schema (e.g., 'public')\n * @param options.desired - Target ordered list of all enum values\n * @param options.existing - Current enum values in the database\n * @returns Array of migration operations to add each missing value\n */\nfunction buildAddValueOperations(options: {\n  typeName: string;\n  nativeType: string;\n  schemaName: string;\n  desired: readonly string[];\n  existing: readonly string[];\n}): SqlMigrationPlanOperation<unknown>[] {\n  const { typeName, nativeType, schemaName } = options;\n  const current = [...options.existing];\n  const currentSet = new Set(current);\n  const operations: SqlMigrationPlanOperation<unknown>[] = [];\n  for (let index = 0; index < options.desired.length; index += 1) {\n    const value = options.desired[index];\n    if (value === undefined) {\n      continue;\n    }\n    if (currentSet.has(value)) {\n      continue;\n    }\n    // Validate the new value doesn't exceed PostgreSQL's label length limit\n    validateEnumValueLength(value, typeName);\n    const { clause, insertAt } = computeInsertPosition({\n      desired: options.desired,\n      desiredIndex: index,\n      current,\n    });\n    // Use IF NOT EXISTS for idempotency - safe to re-run after partial failures.\n    // Supported in PostgreSQL 9.3+, and we require PostgreSQL 12+.\n    operations.push({\n      id: `type.${typeName}.value.${value}`,\n      label: `Add value ${value} to ${typeName}`,\n      summary: `Adds enum value ${value} to ${typeName}`,\n      operationClass: 'widening',\n      target: { id: 'postgres' },\n      precheck: [],\n      execute: [\n        {\n          description: `add value \"${value}\" if not exists`,\n          sql: `ALTER TYPE ${qualifyName(schemaName, nativeType)} ADD VALUE IF NOT EXISTS '${escapeLiteral(\n            value,\n          )}'${clause}`,\n        },\n      ],\n      postcheck: [],\n    });\n    current.splice(insertAt, 0, value);\n    currentSet.add(value);\n  }\n  return operations;\n}\n\n/**\n * Collects columns using the enum type from the contract (desired state).\n * Used for type-safe reference tracking.\n */\nfunction collectEnumColumnsFromContract(\n  contract: Contract<SqlStorage>,\n  typeName: string,\n  nativeType: string,\n): ReadonlyArray<{ table: string; column: string }> {\n  const columns: Array<{ table: string; column: string }> = [];\n  for (const [tableName, table] of Object.entries(contract.storage.tables)) {\n    for (const [columnName, column] of Object.entries(table.columns)) {\n      if (\n        column.typeRef === typeName ||\n        (column.nativeType === nativeType && column.codecId === PG_ENUM_CODEC_ID)\n      ) {\n        columns.push({ table: tableName, column: columnName });\n      }\n    }\n  }\n  return columns;\n}\n\n/**\n * Collects columns using the enum type from the schema IR (live database state).\n * This ensures we find ALL dependent columns, including those added outside the contract\n * (e.g., manual DDL), which is critical for safe enum rebuild operations.\n */\nfunction collectEnumColumnsFromSchema(\n  schema: SqlSchemaIR,\n  nativeType: string,\n): ReadonlyArray<{ table: string; column: string }> {\n  const columns: Array<{ table: string; column: string }> = [];\n  for (const [tableName, table] of Object.entries(schema.tables)) {\n    for (const [columnName, column] of Object.entries(table.columns)) {\n      // Match by nativeType since schema IR doesn't have codecId/typeRef\n      if (column.nativeType === nativeType) {\n        columns.push({ table: tableName, column: columnName });\n      }\n    }\n  }\n  return columns;\n}\n\n/**\n * Collects all columns using the enum type from both contract AND live database.\n * Merges and deduplicates to ensure we migrate ALL dependent columns during rebuild.\n *\n * This is critical for data integrity: if a column exists in the database using\n * this enum but is not in the contract (e.g., added via manual DDL), we must\n * still migrate it to avoid DROP TYPE failures.\n */\nfunction collectAllEnumColumns(\n  contract: Contract<SqlStorage>,\n  schema: SqlSchemaIR,\n  typeName: string,\n  nativeType: string,\n): ReadonlyArray<{ table: string; column: string }> {\n  const contractColumns = collectEnumColumnsFromContract(contract, typeName, nativeType);\n  const schemaColumns = collectEnumColumnsFromSchema(schema, nativeType);\n\n  // Merge and deduplicate using a Set of \"table.column\" keys\n  const seen = new Set<string>();\n  const result: Array<{ table: string; column: string }> = [];\n\n  for (const col of [...contractColumns, ...schemaColumns]) {\n    const key = `${col.table}.${col.column}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(col);\n    }\n  }\n\n  // Sort for deterministic operation order\n  return result.sort((a, b) => {\n    const tableCompare = a.table.localeCompare(b.table);\n    return tableCompare !== 0 ? tableCompare : a.column.localeCompare(b.column);\n  });\n}\n\n/**\n * Builds a SQL check to verify a column's type matches an expected type.\n */\nfunction columnTypeCheck(options: {\n  schemaName: string;\n  tableName: string;\n  columnName: string;\n  expectedType: string;\n}): string {\n  return `SELECT EXISTS (\n  SELECT 1\n  FROM information_schema.columns\n  WHERE table_schema = '${escapeLiteral(options.schemaName)}'\n    AND table_name = '${escapeLiteral(options.tableName)}'\n    AND column_name = '${escapeLiteral(options.columnName)}'\n    AND udt_name = '${escapeLiteral(options.expectedType)}'\n)`;\n}\n\n/** PostgreSQL maximum identifier length (NAMEDATALEN - 1) */\nconst MAX_IDENTIFIER_LENGTH = 63;\n\n/** Suffix added to enum type names during rebuild operations */\nconst REBUILD_SUFFIX = '__pn_rebuild';\n\n/**\n * Builds an SQL check to verify no rows contain any of the removed enum values.\n * This prevents data loss during enum rebuild operations.\n *\n * @param schemaName - PostgreSQL schema name\n * @param tableName - Table containing the enum column\n * @param columnName - Column using the enum type\n * @param removedValues - Array of enum values being removed\n * @returns SQL query that returns true if no rows contain removed values\n */\nfunction noRemovedValuesExistCheck(\n  schemaName: string,\n  tableName: string,\n  columnName: string,\n  removedValues: readonly string[],\n): string {\n  if (removedValues.length === 0) {\n    // No values being removed, always passes\n    return 'SELECT true';\n  }\n  const valuesList = removedValues.map((v) => `'${escapeLiteral(v)}'`).join(', ');\n  return `SELECT NOT EXISTS (\n  SELECT 1 FROM ${qualifyName(schemaName, tableName)}\n  WHERE ${quoteIdentifier(columnName)}::text IN (${valuesList})\n  LIMIT 1\n)`;\n}\n\n/**\n * Builds a migration operation to recreate a PostgreSQL enum type with updated values.\n *\n * This is required when:\n * - Enum values are removed (PostgreSQL doesn't support direct removal)\n * - Enum values are reordered (PostgreSQL doesn't support reordering)\n *\n * The operation:\n * 1. Creates a new enum type with the desired values (temp name)\n * 2. Migrates all columns to use the new type via text cast\n * 3. Drops the original type\n * 4. Renames the temp type to the original name\n *\n * IMPORTANT: If values are being removed and data exists using those values,\n * the operation will fail at the precheck stage with a clear error message.\n * This prevents silent data loss.\n *\n * @param options.typeName - Contract-level type name\n * @param options.nativeType - PostgreSQL type name\n * @param options.schemaName - PostgreSQL schema\n * @param options.values - Desired final enum values\n * @param options.removedValues - Values being removed (for data loss checks)\n * @param options.contract - Full contract for column discovery\n * @param options.schema - Current schema IR for column discovery\n * @returns Migration operation for full enum rebuild\n */\nfunction buildRecreateEnumOperation(options: {\n  typeName: string;\n  nativeType: string;\n  schemaName: string;\n  values: readonly string[];\n  removedValues: readonly string[];\n  contract: Contract<SqlStorage>;\n  schema: SqlSchemaIR;\n}): SqlMigrationPlanOperation<unknown> {\n  const tempTypeName = `${options.nativeType}${REBUILD_SUFFIX}`;\n\n  // Validate temp type name length won't exceed PostgreSQL's 63-character limit.\n  // If it would, PostgreSQL silently truncates which could cause conflicts.\n  if (tempTypeName.length > MAX_IDENTIFIER_LENGTH) {\n    const maxBaseLength = MAX_IDENTIFIER_LENGTH - REBUILD_SUFFIX.length;\n    throw new Error(\n      `Enum type name \"${options.nativeType}\" is too long for rebuild operation. ` +\n        `Maximum length is ${maxBaseLength} characters (type name + \"${REBUILD_SUFFIX}\" suffix ` +\n        `must fit within PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character identifier limit).`,\n    );\n  }\n\n  const qualifiedOriginal = qualifyName(options.schemaName, options.nativeType);\n  const qualifiedTemp = qualifyName(options.schemaName, tempTypeName);\n  const literalValues = options.values.map((value) => `'${escapeLiteral(value)}'`).join(', ');\n\n  // CRITICAL: Collect columns from BOTH contract AND live database.\n  // This ensures we migrate ALL dependent columns, including those added\n  // outside of Prisma Next (e.g., manual DDL). Without this, DROP TYPE\n  // would fail if the database has columns not tracked in the contract.\n  const columnRefs = collectAllEnumColumns(\n    options.contract,\n    options.schema,\n    options.typeName,\n    options.nativeType,\n  );\n\n  const alterColumns = columnRefs.map((ref) => ({\n    description: `alter ${ref.table}.${ref.column} to ${tempTypeName}`,\n    sql: `ALTER TABLE ${qualifyName(options.schemaName, ref.table)}\nALTER COLUMN ${quoteIdentifier(ref.column)}\nTYPE ${qualifiedTemp}\nUSING ${quoteIdentifier(ref.column)}::text::${qualifiedTemp}`,\n  }));\n\n  // Build postchecks to verify:\n  // 1. The final type exists with the correct name\n  // 2. The temp type was cleaned up (renamed away)\n  // 3. All migrated columns now reference the final type\n  const postchecks = [\n    {\n      description: `verify type \"${options.nativeType}\" exists`,\n      sql: enumTypeExistsCheck(options.schemaName, options.nativeType),\n    },\n    {\n      description: `verify temp type \"${tempTypeName}\" was removed`,\n      sql: enumTypeExistsCheck(options.schemaName, tempTypeName, false),\n    },\n    // Verify each column was successfully migrated to the final type\n    ...columnRefs.map((ref) => ({\n      description: `verify ${ref.table}.${ref.column} uses type \"${options.nativeType}\"`,\n      sql: columnTypeCheck({\n        schemaName: options.schemaName,\n        tableName: ref.table,\n        columnName: ref.column,\n        expectedType: options.nativeType,\n      }),\n    })),\n  ];\n\n  return {\n    id: `type.${options.typeName}.rebuild`,\n    label: `Rebuild type ${options.typeName}`,\n    summary: `Recreates enum type ${options.typeName} with updated values`,\n    operationClass: 'destructive',\n    target: { id: 'postgres' },\n    precheck: [\n      {\n        description: `ensure type \"${options.nativeType}\" exists`,\n        sql: enumTypeExistsCheck(options.schemaName, options.nativeType),\n      },\n      // Note: We don't precheck that temp type doesn't exist because we handle\n      // orphaned temp types in the execute step below.\n\n      // CRITICAL: If values are being removed, verify no data exists using those values.\n      // This prevents silent data loss during the rebuild - the USING cast would fail\n      // at runtime if rows contain values that don't exist in the new enum.\n      ...(options.removedValues.length > 0\n        ? columnRefs.map((ref) => ({\n            description: `ensure no rows in ${ref.table}.${ref.column} contain removed values (${options.removedValues.join(', ')})`,\n            sql: noRemovedValuesExistCheck(\n              options.schemaName,\n              ref.table,\n              ref.column,\n              options.removedValues,\n            ),\n          }))\n        : []),\n    ],\n    execute: [\n      // Clean up any orphaned temp type from a previous failed migration.\n      // This makes the operation recoverable without manual intervention.\n      // DROP TYPE IF EXISTS is safe - it's a no-op if the type doesn't exist.\n      {\n        description: `drop orphaned temp type \"${tempTypeName}\" if exists`,\n        sql: `DROP TYPE IF EXISTS ${qualifiedTemp}`,\n      },\n      {\n        description: `create temp type \"${tempTypeName}\"`,\n        sql: `CREATE TYPE ${qualifiedTemp} AS ENUM (${literalValues})`,\n      },\n      ...alterColumns,\n      {\n        description: `drop type \"${options.nativeType}\"`,\n        sql: `DROP TYPE ${qualifiedOriginal}`,\n      },\n      {\n        description: `rename type \"${tempTypeName}\" to \"${options.nativeType}\"`,\n        sql: `ALTER TYPE ${qualifiedTemp} RENAME TO ${quoteIdentifier(options.nativeType)}`,\n      },\n    ],\n    postcheck: postchecks,\n  };\n}\n\n// ============================================================================\n// Codec Control Hooks\n// ============================================================================\n\n/**\n * Postgres enum hooks for planning, verifying, and introspecting `storage.types`.\n */\nexport const pgEnumControlHooks: CodecControlHooks = {\n  planTypeOperations: ({ typeName, typeInstance, contract, schema, schemaName }) => {\n    const desired = getEnumValues(typeInstance);\n    if (!desired || desired.length === 0) {\n      return { operations: [] };\n    }\n\n    const schemaNamespace = schemaName ?? 'public';\n    const existing = readExistingEnumValues(schema, typeInstance.nativeType);\n    if (!existing) {\n      return {\n        operations: [\n          buildCreateEnumOperation(typeName, typeInstance.nativeType, schemaNamespace, desired),\n        ],\n      };\n    }\n\n    const diff = determineEnumDiff(existing, desired);\n    if (diff.kind === 'unchanged') {\n      return { operations: [] };\n    }\n\n    if (diff.kind === 'rebuild') {\n      return {\n        operations: [\n          buildRecreateEnumOperation({\n            typeName,\n            nativeType: typeInstance.nativeType,\n            schemaName: schemaNamespace,\n            values: desired,\n            removedValues: diff.removedValues,\n            contract,\n            schema,\n          }),\n        ],\n      };\n    }\n\n    return {\n      operations: buildAddValueOperations({\n        typeName,\n        nativeType: typeInstance.nativeType,\n        schemaName: schemaNamespace,\n        desired,\n        existing,\n      }),\n    };\n  },\n  verifyType: ({ typeName, typeInstance, schema }) => {\n    const desired = getEnumValues(typeInstance);\n    if (!desired) {\n      return [];\n    }\n    const existing = readExistingEnumValues(schema, typeInstance.nativeType);\n    if (!existing) {\n      return [\n        {\n          kind: 'type_missing',\n          typeName,\n          message: `Type \"${typeName}\" is missing from database`,\n        },\n      ];\n    }\n    const diff = determineEnumDiff(existing, desired);\n    if (diff.kind === 'unchanged') return [];\n    const existingSet = new Set(existing);\n    const desiredSet = new Set(desired);\n    const addedValues = desired.filter((v) => !existingSet.has(v));\n    const removedValues = existing.filter((v) => !desiredSet.has(v));\n    return [\n      {\n        kind: 'enum_values_changed' as const,\n        typeName,\n        addedValues,\n        removedValues,\n        message:\n          diff.kind === 'add_values'\n            ? `Enum type \"${typeName}\" needs new values: ${addedValues.join(', ')}`\n            : `Enum type \"${typeName}\" values changed (requires rebuild): +[${addedValues.join(', ')}] -[${removedValues.join(', ')}]`,\n      },\n    ];\n  },\n  introspectTypes: async ({ driver, schemaName }) => {\n    const namespace = schemaName ?? 'public';\n    const result = await driver.query<EnumRow>(ENUM_INTROSPECT_QUERY, [namespace]);\n    const types: Record<string, StorageTypeInstance> = {};\n    for (const row of result.rows) {\n      const values = parsePostgresArray(row.values);\n      if (!values) {\n        throw new Error(\n          `Failed to parse enum values for type \"${row.type_name}\": ` +\n            `unexpected format: ${JSON.stringify(row.values)}`,\n        );\n      }\n      types[row.type_name] = {\n        codecId: PG_ENUM_CODEC_ID,\n        nativeType: row.type_name,\n        typeParams: { values },\n      };\n    }\n    return types;\n  },\n};\n","import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';\nimport { buildOperation, refsOf, toExpr } from '@prisma-next/sql-relational-core/expression';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_BYTEA_CODEC_ID,\n  PG_CHAR_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  PG_VARCHAR_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\nimport { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';\nimport type { QueryOperationTypes } from '../types/operation-types';\nimport { pgEnumControlHooks } from './enum-control-hooks';\n\n// ============================================================================ Helper functions for reducing boilerplate ============================================================================\n\n/** Creates a type import spec for codec types */\nconst codecTypeImport = (named: string) =>\n  ({\n    package: '@prisma-next/target-postgres/codec-types',\n    named,\n    alias: named,\n  }) as const;\n\nfunction isPositiveInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0\n  );\n}\n\nfunction isNonNegativeInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0\n  );\n}\n\nfunction expandLength({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('length' in typeParams)) {\n    return nativeType;\n  }\n  const length = typeParams['length'];\n  if (!isPositiveInteger(length)) {\n    throw new Error(\n      `Invalid \"length\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(length)}`,\n    );\n  }\n  return `${nativeType}(${length})`;\n}\n\nfunction expandPrecision({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('precision' in typeParams)) {\n    return nativeType;\n  }\n  const precision = typeParams['precision'];\n  if (!isPositiveInteger(precision)) {\n    throw new Error(\n      `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n    );\n  }\n  return `${nativeType}(${precision})`;\n}\n\nfunction expandNumeric({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  const hasPrecision = typeParams && 'precision' in typeParams;\n  const hasScale = typeParams && 'scale' in typeParams;\n\n  if (!hasPrecision && !hasScale) {\n    return nativeType;\n  }\n\n  if (!hasPrecision && hasScale) {\n    throw new Error(\n      `Invalid type parameters for \"${nativeType}\": \"scale\" requires \"precision\" to be specified`,\n    );\n  }\n\n  if (hasPrecision) {\n    const precision = typeParams['precision'];\n    if (!isPositiveInteger(precision)) {\n      throw new Error(\n        `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n      );\n    }\n    if (hasScale) {\n      const scale = typeParams['scale'];\n      if (!isNonNegativeInteger(scale)) {\n        throw new Error(\n          `Invalid \"scale\" type parameter for \"${nativeType}\": expected a non-negative integer, got ${JSON.stringify(scale)}`,\n        );\n      }\n      return `${nativeType}(${precision},${scale})`;\n    }\n    return `${nativeType}(${precision})`;\n  }\n\n  return nativeType;\n}\n\nconst lengthHooks: CodecControlHooks = { expandNativeType: expandLength };\nconst precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };\nconst numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };\nconst identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };\n\n// ============================================================================ Descriptor metadata ============================================================================\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nexport function postgresQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    ilike: {\n      self: { traits: ['textual'] },\n      impl: (self, pattern) => {\n        const selfRefs = refsOf(self);\n        return buildOperation({\n          method: 'ilike',\n          args: [toExpr(self), toExpr(pattern, PG_TEXT_CODEC_ID, selfRefs)],\n          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },\n          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },\n        });\n      },\n    },\n  };\n}\n\nexport const postgresAdapterDescriptorMeta = {\n  kind: 'adapter',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      orderBy: true,\n      limit: true,\n      lateral: true,\n      jsonAgg: true,\n      returning: true,\n    },\n    sql: {\n      enums: true,\n      returning: true,\n      defaultInInsert: true,\n    },\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(postgresCodecRegistry.values()),\n      import: {\n        package: '@prisma-next/target-postgres/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/target-postgres/codec-types',\n          named: 'JsonValue',\n          alias: 'JsonValue',\n        },\n        codecTypeImport('Char'),\n        codecTypeImport('Varchar'),\n        codecTypeImport('Numeric'),\n        codecTypeImport('Bit'),\n        codecTypeImport('VarBit'),\n        codecTypeImport('Timestamp'),\n        codecTypeImport('Timestamptz'),\n        codecTypeImport('Time'),\n        codecTypeImport('Timetz'),\n        codecTypeImport('Interval'),\n      ],\n      controlPlaneHooks: {\n        [SQL_CHAR_CODEC_ID]: lengthHooks,\n        [SQL_VARCHAR_CODEC_ID]: lengthHooks,\n        [SQL_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_CHAR_CODEC_ID]: lengthHooks,\n        [PG_VARCHAR_CODEC_ID]: lengthHooks,\n        [PG_NUMERIC_CODEC_ID]: numericHooks,\n        [PG_BIT_CODEC_ID]: lengthHooks,\n        [PG_VARBIT_CODEC_ID]: lengthHooks,\n        [PG_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,\n        [PG_TIME_CODEC_ID]: precisionHooks,\n        [PG_TIMETZ_CODEC_ID]: precisionHooks,\n        [PG_INTERVAL_CODEC_ID]: precisionHooks,\n        [PG_ENUM_CODEC_ID]: pgEnumControlHooks,\n        [PG_JSON_CODEC_ID]: identityHooks,\n        [PG_JSONB_CODEC_ID]: identityHooks,\n        [PG_BYTEA_CODEC_ID]: identityHooks,\n      },\n    },\n    storage: [\n      { typeId: PG_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: SQL_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: SQL_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: SQL_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      {\n        typeId: SQL_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      { typeId: PG_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: PG_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: PG_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_INT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_INT2_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },\n      { typeId: PG_INT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },\n      { typeId: PG_FLOAT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },\n      { typeId: PG_FLOAT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_NUMERIC_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'numeric' },\n      {\n        typeId: PG_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      {\n        typeId: PG_TIMESTAMPTZ_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamptz',\n      },\n      { typeId: PG_TIME_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'time' },\n      { typeId: PG_TIMETZ_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'timetz' },\n      { typeId: PG_BOOL_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },\n      { typeId: PG_BIT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bit' },\n      {\n        typeId: PG_VARBIT_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'bit varying',\n      },\n      {\n        typeId: PG_INTERVAL_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'interval',\n      },\n      { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },\n      { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },\n      { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },\n    ],\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/adapter-postgres/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PgAdapterQueryOps',\n      },\n    },\n  },\n} as const;\n"],"mappings":"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"}

package/dist/operation-types.d.mts

@@ -1,19 +1,20 @@
+import { CodecExpression, Expression, TraitExpression } from "@prisma-next/sql-relational-core/expression";
 import { SqlQueryOperationTypes } from "@prisma-next/sql-contract/types";
 
 //#region src/types/operation-types.d.ts
-type QueryOperationTypes = SqlQueryOperationTypes<{
+type CodecTypesBase = Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>;
+type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<CT, {
   readonly ilike: {
-    readonly args: readonly [{
+    readonly self: {
       readonly traits: readonly ['textual'];
-      readonly nullable: false;
-    }, {
-      readonly codecId: 'pg/text@1';
-      readonly nullable: false;
-    }];
-    readonly returns: {
-      readonly codecId: 'pg/bool@1';
-      readonly nullable: false;
     };
+    readonly impl: (self: TraitExpression<readonly ['textual'], false, CT>, pattern: CodecExpression<'pg/text@1', false, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
   };
 }>;
 //#endregion

package/dist/operation-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-types.d.mts","names":[],"sources":["../src/types/operation-types.ts"],"sourcesContent":[],"mappings":";;;KAEY,mBAAA,GAAsB;;IAAtB,SAAA,IAAA,EAAA,SAAmB"}
+{"version":3,"file":"operation-types.d.mts","names":[],"sources":["../src/types/operation-types.ts"],"mappings":";;;;KAOK,cAAA,GAAiB,MAAA;EAAA,SAA0B,KAAA;EAAA,SAAyB,MAAA;AAAA;AAAA,KAE7D,mBAAA,YAA+B,cAAA,IAAkB,sBAAA,CAC3D,EAAA;EAAA,SAEW,KAAA;IAAA,SACE,IAAA;MAAA,SAAiB,MAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,8BAA6C,EAAA,GACnD,OAAA,EAAS,eAAA,qBAAoC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;AAAA"}

package/dist/operation-types.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/runtime.d.mts

@@ -1,19 +1,11 @@
-import { c as PostgresContract, l as PostgresLoweredStatement } from "./types-CfRPdAk8.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement } from "./types-B1eiuBHQ.mjs";
+import { SqlRuntimeAdapterDescriptor } from "@prisma-next/sql-runtime";
 import { Adapter, AnyQueryAst } from "@prisma-next/sql-relational-core/ast";
 import { RuntimeAdapterInstance } from "@prisma-next/framework-components/execution";
-import { SqlRuntimeAdapterDescriptor } from "@prisma-next/sql-runtime";
-import { JsonSchemaValidateFn } from "@prisma-next/sql-relational-core/query-lane-context";
 
 //#region src/exports/runtime.d.ts
 interface SqlRuntimeAdapter extends RuntimeAdapterInstance<'sql', 'postgres'>, Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}
-/**
- * Helper returned by the JSON/JSONB `init` hook.
- * Contains a compiled JSON Schema validate function for runtime conformance checks.
- */
-type JsonCodecHelper = {
-  readonly validate: JsonSchemaValidateFn;
-};
 declare const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>;
 //#endregion
-export { JsonCodecHelper, SqlRuntimeAdapter, postgresRuntimeAdapterDescriptor as default };
+export { SqlRuntimeAdapter, postgresRuntimeAdapterDescriptor as default };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;;;;UAqBiB,iBAAA,SACP,2CACN,QAAQ,aAAa,kBAAkB;AAF3C;;;;AACU,KAuBE,eAAA,GAvBF;EACN,SAAA,QAAA,EAsB+C,oBAtB/C;CAAO;AAsBX,cA+BM,gCA/B6C,EA+BX,2BA/B+B,CAAA,UAAA,EA+BS,iBA/BT,CAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"mappings":";;;;;;UAaiB,iBAAA,SACP,sBAAA,qBACN,OAAA,CAAQ,WAAA,EAAa,gBAAA,EAAkB,wBAAA;AAAA,cAgBrC,gCAAA,EAAkC,2BAAA,aAAwC,iBAAA"}

package/dist/runtime.mjs

@@ -1,99 +1,37 @@
-import { t as createPostgresAdapter } from "./adapter-hNElNHo4.mjs";
-import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-RTDzyrae.mjs";
-import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
-import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
-import { PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
+import { t as createPostgresAdapter } from "./adapter-CBaRvhQF.mjs";
+import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-CyjnYUWG.mjs";
+import { extractCodecLookup } from "@prisma-next/framework-components/control";
+import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
 import { builtinGeneratorIds } from "@prisma-next/ids";
+import { timestampNowRuntimeGenerator } from "@prisma-next/family-sql/runtime";
 import { generateId } from "@prisma-next/ids/runtime";
-import { type } from "arktype";
-import Ajv from "ajv";
-
-//#region src/core/json-schema-validator.ts
-/**
-* Shared Ajv instance for all JSON Schema validators.
-* Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.
-*/
-let sharedAjv;
-function getSharedAjv() {
-	if (!sharedAjv) sharedAjv = new Ajv({
-		allErrors: false,
-		strict: false
-	});
-	return sharedAjv;
-}
-/**
-* Compiles a JSON Schema object into a reusable validate function using Ajv.
-*
-* The returned function validates a value against the schema and returns
-* a structured result with error details on failure.
-*
-* Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)
-* to minimize memory and CPU overhead.
-*
-* @param schema - A JSON Schema object (draft-07 compatible)
-* @returns A validate function
-*/
-function compileJsonSchemaValidator(schema) {
-	const validate = getSharedAjv().compile(schema);
-	return (value) => {
-		if (validate(value)) return { valid: true };
-		return {
-			valid: false,
-			errors: validate.errors.map((err) => ({
-				path: err.instancePath || "/",
-				message: err.message ?? "unknown validation error",
-				keyword: err.keyword
-			}))
-		};
-	};
-}
-
-//#endregion
 //#region src/exports/runtime.ts
-function createPostgresCodecRegistry() {
-	const registry = createCodecRegistry();
-	for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
-	return registry;
-}
-const jsonTypeParamsSchema = type({
-	schemaJson: "object",
-	"type?": "string"
-});
 function createPostgresMutationDefaultGenerators() {
-	return builtinGeneratorIds.map((id) => ({
+	return [...builtinGeneratorIds.map((id) => ({
 		id,
 		generate: (params) => {
 			return generateId(params ? {
 				id,
 				params
 			} : { id });
-		}
-	}));
-}
-function initJsonCodecHelper(params) {
-	return { validate: compileJsonSchemaValidator(params.schemaJson) };
+		},
+		stability: "field"
+	})), timestampNowRuntimeGenerator()];
 }
-const parameterizedCodecDescriptors = [{
-	codecId: PG_JSON_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}, {
-	codecId: PG_JSONB_CODEC_ID,
-	paramsSchema: jsonTypeParamsSchema,
-	init: initJsonCodecHelper
-}];
 const postgresRuntimeAdapterDescriptor = {
 	...postgresAdapterDescriptorMeta,
-	codecs: createPostgresCodecRegistry,
-	parameterizedCodecs: () => parameterizedCodecDescriptors,
-	queryOperations: () => postgresQueryOperations,
+	codecs: () => Array.from(postgresCodecRegistry.values()),
+	queryOperations: () => postgresQueryOperations(),
 	mutationDefaultGenerators: createPostgresMutationDefaultGenerators,
-	create(_stack) {
-		return createPostgresAdapter();
+	create(stack) {
+		return createPostgresAdapter({ codecLookup: extractCodecLookup([
+			stack.target,
+			stack.adapter,
+			...stack.extensionPacks
+		]) });
 	}
 };
-var runtime_default = postgresRuntimeAdapterDescriptor;
-
 //#endregion
-export { runtime_default as default };
+export { postgresRuntimeAdapterDescriptor as default };
+
 //# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["sharedAjv: Ajv | undefined","arktype","postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter>"],"sources":["../src/core/json-schema-validator.ts","../src/exports/runtime.ts"],"sourcesContent":["import type {\n  JsonSchemaValidateFn,\n  JsonSchemaValidationError,\n  JsonSchemaValidationResult,\n} from '@prisma-next/sql-relational-core/query-lane-context';\nimport Ajv from 'ajv';\n\nexport type { JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult };\n\n/**\n * Shared Ajv instance for all JSON Schema validators.\n * Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.\n */\nlet sharedAjv: Ajv | undefined;\n\nfunction getSharedAjv(): Ajv {\n  if (!sharedAjv) {\n    sharedAjv = new Ajv({ allErrors: false, strict: false });\n  }\n  return sharedAjv;\n}\n\n/**\n * Compiles a JSON Schema object into a reusable validate function using Ajv.\n *\n * The returned function validates a value against the schema and returns\n * a structured result with error details on failure.\n *\n * Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)\n * to minimize memory and CPU overhead.\n *\n * @param schema - A JSON Schema object (draft-07 compatible)\n * @returns A validate function\n */\nexport function compileJsonSchemaValidator(schema: Record<string, unknown>): JsonSchemaValidateFn {\n  const ajv = getSharedAjv();\n  const validate = ajv.compile(schema);\n\n  return (value: unknown): JsonSchemaValidationResult => {\n    const valid = validate(value);\n    if (valid) {\n      return { valid: true };\n    }\n\n    // biome-ignore lint/style/noNonNullAssertion: Ajv guarantees `errors` is populated whenever `validate(...)` returns false.\n    const errors: JsonSchemaValidationError[] = validate.errors!.map((err) => ({\n      path: err.instancePath || '/',\n      message: err.message ?? 'unknown validation error',\n      keyword: err.keyword,\n    }));\n\n    return { valid: false, errors };\n  };\n}\n","import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst, CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeAdapterDescriptor,\n} from '@prisma-next/sql-runtime';\nimport { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { type as arktype } from 'arktype';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport {\n  compileJsonSchemaValidator,\n  type JsonSchemaValidateFn,\n} from '../core/json-schema-validator';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresCodecRegistry(): CodecRegistry {\n  const registry = createCodecRegistry();\n  for (const definition of Object.values(codecDefinitions)) {\n    registry.register(definition.codec);\n  }\n  return registry;\n}\n\nconst jsonTypeParamsSchema = arktype({\n  schemaJson: 'object',\n  'type?': 'string',\n});\n\n/** The inferred type params shape from the arktype schema. */\ntype JsonTypeParams = typeof jsonTypeParamsSchema.infer;\n\n/**\n * Helper returned by the JSON/JSONB `init` hook.\n * Contains a compiled JSON Schema validate function for runtime conformance checks.\n */\nexport type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };\n\nfunction createPostgresMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => {\n      const spec: GeneratedValueSpec = params ? { id, params } : { id };\n      return generateId(spec);\n    },\n  }));\n}\n\nfunction initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {\n  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };\n}\n\nconst parameterizedCodecDescriptors = [\n  {\n    codecId: PG_JSON_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n  {\n    codecId: PG_JSONB_CODEC_ID,\n    paramsSchema: jsonTypeParamsSchema,\n    init: initJsonCodecHelper,\n  },\n] as const satisfies ReadonlyArray<\n  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>\n>;\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: createPostgresCodecRegistry,\n    parameterizedCodecs: () => parameterizedCodecDescriptors,\n    queryOperations: () => postgresQueryOperations,\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapter {\n      return createPostgresAdapter();\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;AAaA,IAAIA;AAEJ,SAAS,eAAoB;AAC3B,KAAI,CAAC,UACH,aAAY,IAAI,IAAI;EAAE,WAAW;EAAO,QAAQ;EAAO,CAAC;AAE1D,QAAO;;;;;;;;;;;;;;AAeT,SAAgB,2BAA2B,QAAuD;CAEhG,MAAM,WADM,cAAc,CACL,QAAQ,OAAO;AAEpC,SAAQ,UAA+C;AAErD,MADc,SAAS,MAAM,CAE3B,QAAO,EAAE,OAAO,MAAM;AAUxB,SAAO;GAAE,OAAO;GAAO,QANqB,SAAS,OAAQ,KAAK,SAAS;IACzE,MAAM,IAAI,gBAAgB;IAC1B,SAAS,IAAI,WAAW;IACxB,SAAS,IAAI;IACd,EAAE;GAE4B;;;;;;AC1BnC,SAAS,8BAA6C;CACpD,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,QAAO;;AAGT,MAAM,uBAAuBC,KAAQ;CACnC,YAAY;CACZ,SAAS;CACV,CAAC;AAWF,SAAS,0CAA0C;AACjD,QAAO,oBAAoB,KAAK,QAAQ;EACtC;EACA,WAAW,WAAqC;AAE9C,UAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAE1B,EAAE;;AAGL,SAAS,oBAAoB,QAAyC;AACpE,QAAO,EAAE,UAAU,2BAA2B,OAAO,WAAsC,EAAE;;AAG/F,MAAM,gCAAgC,CACpC;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,EACD;CACE,SAAS;CACT,cAAc;CACd,MAAM;CACP,CACF;AAID,MAAMC,mCACJ;CACE,GAAG;CACH,QAAQ;CACR,2BAA2B;CAC3B,uBAAuB;CACvB,2BAA2B;CAC3B,OAAO,QAA2B;AAChC,SAAO,uBAAuB;;CAEjC;AAEH,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { GeneratedValueSpec } from '@prisma-next/contract/types';\nimport { timestampNowRuntimeGenerator } from '@prisma-next/family-sql/runtime';\nimport { extractCodecLookup } from '@prisma-next/framework-components/control';\nimport type { RuntimeAdapterInstance } from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { Adapter, AnyQueryAst } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlRuntimeAdapterDescriptor } from '@prisma-next/sql-runtime';\nimport { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';\nimport { createPostgresAdapter } from '../core/adapter';\nimport { postgresAdapterDescriptorMeta, postgresQueryOperations } from '../core/descriptor-meta';\nimport type { PostgresContract, PostgresLoweredStatement } from '../core/types';\n\nexport interface SqlRuntimeAdapter\n  extends RuntimeAdapterInstance<'sql', 'postgres'>,\n    Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {}\n\nfunction createPostgresMutationDefaultGenerators() {\n  return [\n    ...builtinGeneratorIds.map((id) => ({\n      id,\n      generate: (params?: Record<string, unknown>) => {\n        const spec: GeneratedValueSpec = params ? { id, params } : { id };\n        return generateId(spec);\n      },\n      stability: 'field' as const,\n    })),\n    timestampNowRuntimeGenerator(),\n  ];\n}\n\nconst postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =\n  {\n    ...postgresAdapterDescriptorMeta,\n    codecs: () => Array.from(postgresCodecRegistry.values()),\n    queryOperations: () => postgresQueryOperations(),\n    mutationDefaultGenerators: createPostgresMutationDefaultGenerators,\n    create(stack): SqlRuntimeAdapter {\n      // The runtime `ExecutionStack` does not (yet) carry a pre-assembled `codecLookup` field the way the control `ControlStack` does, so we derive an equivalent lookup here from the stack's component metadata (target + adapter + extension packs) using the same assembly helper that `createControlStack` uses. This keeps the renderer fed with the same codec set on both planes — including extension-contributed codecs like\n      // `pg/vector@1` from `@prisma-next/extension-pgvector`.\n      const codecLookup = extractCodecLookup([\n        stack.target,\n        stack.adapter,\n        ...stack.extensionPacks,\n      ]);\n      return createPostgresAdapter({ codecLookup });\n    },\n  };\n\nexport default postgresRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;AAiBA,SAAS,0CAA0C;CACjD,OAAO,CACL,GAAG,oBAAoB,KAAK,QAAQ;EAClC;EACA,WAAW,WAAqC;GAE9C,OAAO,WAD0B,SAAS;IAAE;IAAI;IAAQ,GAAG,EAAE,IAAI,CAC1C;;EAEzB,WAAW;EACZ,EAAE,EACH,8BAA8B,CAC/B;;AAGH,MAAM,mCACJ;CACE,GAAG;CACH,cAAc,MAAM,KAAK,sBAAsB,QAAQ,CAAC;CACxD,uBAAuB,yBAAyB;CAChD,2BAA2B;CAC3B,OAAO,OAA0B;EAQ/B,OAAO,sBAAsB,EAAE,aALX,mBAAmB;GACrC,MAAM;GACN,MAAM;GACN,GAAG,MAAM;GACV,CACyC,EAAE,CAAC;;CAEhD"}

package/dist/{sql-renderer-pEaSP82_.mjs → sql-renderer-wTVSEy5H.mjs}

@@ -1,57 +1,98 @@
-import { LiteralExpr } from "@prisma-next/sql-relational-core/ast";
-import { PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
+import { extractCodecLookup } from "@prisma-next/framework-components/control";
+import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
+import { LiteralExpr, collectOrderedParamRefs } from "@prisma-next/sql-relational-core/ast";
 import { escapeLiteral, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
-
+//#region src/core/codec-lookup.ts
+/**
+* Build a {@link CodecLookup} populated with the Postgres-builtin codec definitions only.
+*
+* This is the default lookup used by `createPostgresAdapter()` and `new PostgresControlAdapter()` when called without a stack-derived lookup (e.g. from tests, or one-off scripts that don't compose a full stack).
+*
+* Extension codecs (e.g. `pg/vector@1` from `@prisma-next/extension-pgvector`) are intentionally NOT included here: a bare adapter cannot see extensions. Stack-composed paths (`SqlControlAdapterDescriptor.create(stack)` / `SqlRuntimeAdapterDescriptor.create(stack)`) supply the broader, extension-inclusive lookup at construction time.
+*/
+function createPostgresBuiltinCodecLookup() {
+	return extractCodecLookup([{
+		id: "postgres-builtin-codecs",
+		types: { codecTypes: { codecDescriptors: Array.from(postgresCodecRegistry.values()) } }
+	}]);
+}
+//#endregion
 //#region src/core/sql-renderer.ts
-const VECTOR_CODEC_ID = "pg/vector@1";
 /**
-* Map a codec ID to its `::cast` suffix, if Postgres requires one for
-* parameterized values (e.g. `$1::vector`, `$1::jsonb`).
+* Postgres native types whose unknown-OID parameter inference is reliable in arbitrary expression positions. Parameters bound to a codec whose `meta.db.sql.postgres.nativeType` falls in this set are emitted as plain `$N`; everything else (including `json`, `jsonb`, extension types like `vector`, and unknown user types) is emitted as `$N::<nativeType>` so the planner picks an unambiguous overload.
+*
+* `json` / `jsonb` are intentionally excluded despite being Postgres builtins: their operator overloads make context inference unreliable in expression positions (e.g. `$1 -> 'key'` is ambiguous between the two).
 *
-* NOTE: hardcoded codec IDs here are a known wart, tracked separately by
-* TML-2310 ("Move SQL param-cast metadata onto codec descriptors").
-* Until that lands the cast lives on the renderer rather than the codec.
+* Spellings match the on-disk `meta.db.sql.postgres.nativeType` values in `@prisma-next/target-postgres`'s codec definitions, not the `udt_name` abbreviations that ADR 205 used as illustrative shorthand. The lookup-based cast policy compares against these strings directly.
 */
-function getCodecParamCast(codecId) {
-	if (codecId === VECTOR_CODEC_ID) return "vector";
-	if (codecId === PG_JSON_CODEC_ID) return "json";
-	if (codecId === PG_JSONB_CODEC_ID) return "jsonb";
+const POSTGRES_INFERRABLE_NATIVE_TYPES = new Set([
+	"integer",
+	"smallint",
+	"bigint",
+	"real",
+	"double precision",
+	"numeric",
+	"boolean",
+	"text",
+	"character",
+	"character varying",
+	"timestamp",
+	"timestamp without time zone",
+	"timestamp with time zone",
+	"time",
+	"timetz",
+	"interval",
+	"bit",
+	"bit varying"
+]);
+function renderTypedParam(index, codecId, codecLookup) {
+	if (codecId === void 0) return `$${index}`;
+	if (codecLookup.get(codecId) === void 0) throw new Error(`Postgres lowering: ParamRef carries codecId "${codecId}" but the assembled codec lookup has no entry for it. This usually indicates a missing extension pack in the runtime stack — register the pack that contributes this codec (e.g. \`extensionPacks: [pgvectorRuntime]\`), or use the codec directly from \`@prisma-next/target-postgres/codecs\` if it's a builtin.`);
+	const dbRecord = codecLookup.metaFor(codecId)?.db;
+	const sqlBlock = isRecord(dbRecord) ? dbRecord["sql"] : void 0;
+	const dialectBlock = isRecord(sqlBlock) ? sqlBlock["postgres"] : void 0;
+	const nativeType = isRecord(dialectBlock) ? dialectBlock["nativeType"] : void 0;
+	if (typeof nativeType === "string" && !POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) return `$${index}::${nativeType}`;
+	return `$${index}`;
 }
-function renderTypedParam(index, codecId) {
-	const cast = getCodecParamCast(codecId);
-	return cast ? `$${index}::${cast}` : `$${index}`;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
 }
 /**
 * Render a SQL query AST to a Postgres-flavored `{ sql, params }` payload.
 *
-* Shared between the runtime (`PostgresAdapterImpl.lower`) and control
-* (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time
-* paths produce byte-identical output for the same AST.
+* Shared between the runtime (`PostgresAdapterImpl.lower`) and control (`PostgresControlAdapter.lower`) entrypoints so emit-time and run-time paths produce byte-identical output for the same AST.
 */
-function renderLoweredSql(ast, contract) {
-	const collectedParamRefs = ast.collectParamRefs();
-	const paramIndexMap = /* @__PURE__ */ new Map();
-	const params = [];
-	for (const ref of collectedParamRefs) {
-		if (paramIndexMap.has(ref)) continue;
-		paramIndexMap.set(ref, params.length + 1);
-		params.push(ref.value);
-	}
+function renderLoweredSql(ast, contract, codecLookup) {
+	const orderedRefs = collectOrderedParamRefs(ast);
+	const indexMap = /* @__PURE__ */ new Map();
+	const params = orderedRefs.map((ref, i) => {
+		indexMap.set(ref, i + 1);
+		return ref.value;
+	});
+	const pim = {
+		indexMap,
+		codecLookup
+	};
 	const node = ast;
 	let sql;
 	switch (node.kind) {
 		case "select":
-			sql = renderSelect(node, contract, paramIndexMap);
+			sql = renderSelect(node, contract, pim);
 			break;
 		case "insert":
-			sql = renderInsert(node, contract, paramIndexMap);
+			sql = renderInsert(node, contract, pim);
 			break;
 		case "update":
-			sql = renderUpdate(node, contract, paramIndexMap);
+			sql = renderUpdate(node, contract, pim);
 			break;
 		case "delete":
-			sql = renderDelete(node, contract, paramIndexMap);
+			sql = renderDelete(node, contract, pim);
 			break;
+		case "raw-sql":
+			sql = renderRawSql(node, contract, pim);
+			break;
+		// v8 ignore next 4
 		default: throw new Error(`Unsupported AST node kind: ${node.kind}`);
 	}
 	return Object.freeze({
@@ -81,6 +122,16 @@ function renderProjection(projection, contract, pim) {
 		return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
 	}).join(", ");
 }
+function renderReturning(items, contract, pim) {
+	return items.map((item) => {
+		if (item.expr.kind === "column-ref") {
+			const rendered = renderColumn(item.expr);
+			return item.expr.column === item.alias ? rendered : `${rendered} AS ${quoteIdentifier(item.alias)}`;
+		}
+		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${quoteIdentifier(item.alias)}`;
+		return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
+	}).join(", ");
+}
 function renderDistinctPrefix(distinct, distinctOn, contract, pim) {
 	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
 	if (distinct) return "DISTINCT ";
@@ -95,6 +146,7 @@ function renderSource(source, contract, pim) {
 			return `${table} AS ${quoteIdentifier(node.alias)}`;
 		}
 		case "derived-table-source": return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+		// v8 ignore next 4
 		default: throw new Error(`Unsupported source node kind: ${node.kind}`);
 	}
 }
@@ -114,15 +166,9 @@ function renderNullCheck(expr, contract, pim) {
 	return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
 }
 /**
-* Atomic expression kinds whose rendered SQL is already self-delimited
-* (a column reference, parameter, literal, function call, aggregate, etc.)
-* and therefore does not need surrounding parentheses when used as the
-* left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`,
-* or as either operand of a binary infix operator.
+* Atomic expression kinds whose rendered SQL is already self-delimited (a column reference, parameter, literal, function call, aggregate, etc.) and therefore does not need surrounding parentheses when used as the left operand of a postfix predicate like `IS NULL` or `IS NOT NULL`, or as either operand of a binary infix operator.
 *
-* Anything not in this set is treated as composite (binary, AND/OR/NOT,
-* EXISTS, nested IS NULL, subqueries, operation templates) and gets
-* wrapped to preserve grouping.
+* Anything not in this set is treated as composite (binary, AND/OR/NOT, EXISTS, nested IS NULL, subqueries, operation templates) and gets wrapped to preserve grouping.
 */
 function isAtomicExpressionKind(kind) {
 	switch (kind) {
@@ -239,13 +285,14 @@ function renderExpr(expr, contract, pim) {
 		case "param-ref": return renderParamRef(node, pim);
 		case "literal": return renderLiteral(node);
 		case "list": return renderListLiteral(node, contract, pim);
+		// v8 ignore next 4
 		default: throw new Error(`Unsupported expression node kind: ${node.kind}`);
 	}
 }
 function renderParamRef(ref, pim) {
-	const index = pim.get(ref);
+	const index = pim.indexMap.get(ref);
 	if (index === void 0) throw new Error("ParamRef not found in index map");
-	return renderTypedParam(index, ref.codecId);
+	return renderTypedParam(index, ref.codecId, pim.codecLookup);
 }
 function renderLiteral(expr) {
 	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
@@ -296,6 +343,7 @@ function renderInsertValue(value, pim) {
 	switch (value.kind) {
 		case "param-ref": return renderParamRef(value, pim);
 		case "column-ref": return renderColumn(value);
+		// v8 ignore next 4
 		default: throw new Error(`Unsupported value node in INSERT: ${value.kind}`);
 	}
 }
@@ -335,9 +383,10 @@ function renderInsert(ast, contract, pim) {
 				});
 				return ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
 			}
+			// v8 ignore next 4
 			default: throw new Error(`Unsupported onConflict action: ${action.kind}`);
 		}
-	})() : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+	})() : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
 }
 function renderUpdate(ast, contract, pim) {
 	const table = quoteIdentifier(ast.table.name);
@@ -353,18 +402,30 @@ function renderUpdate(ast, contract, pim) {
 			case "column-ref":
 				value = renderColumn(val);
 				break;
+			// v8 ignore next 4
 			default: throw new Error(`Unsupported value node in UPDATE: ${val.kind}`);
 		}
 		return `${column} = ${value}`;
 	});
 	const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : "";
-	const returningClause = ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : "";
+	const returningClause = ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : "";
 	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
 }
 function renderDelete(ast, contract, pim) {
-	return `DELETE FROM ${quoteIdentifier(ast.table.name)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+	return `DELETE FROM ${quoteIdentifier(ast.table.name)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
+}
+function renderRawSql(ast, contract, pim) {
+	const out = [];
+	for (let i = 0; i < ast.fragments.length; i++) {
+		out.push(ast.fragments[i] ?? "");
+		if (i < ast.args.length) {
+			const arg = ast.args[i];
+			if (arg !== void 0) out.push(renderExpr(arg, contract, pim));
+		}
+	}
+	return out.join("");
 }
-
 //#endregion
-export { renderLoweredSql as t };
-//# sourceMappingURL=sql-renderer-pEaSP82_.mjs.map
+export { createPostgresBuiltinCodecLookup as n, renderLoweredSql as t };
+
+//# sourceMappingURL=sql-renderer-wTVSEy5H.mjs.map