effect-qb 0.19.0 → 0.20.0

package/dist/standard.js

@@ -44,7 +44,7 @@ import * as Schema4 from "effect/Schema";
 import * as Schema2 from "effect/Schema";
 
 // src/internal/column-state.ts
-import { pipeArguments } from "effect/Pipeable";
+import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
 import * as Schema from "effect/Schema";
 
 // src/internal/scalar.ts
@@ -57,12 +57,181 @@ var TypeId = Symbol.for("effect-qb/Expression");
 // src/internal/expression-ast.ts
 var TypeId2 = Symbol.for("effect-qb/ExpressionAst");
 
+// src/internal/json/path-access.ts
+import { pipeArguments } from "effect/Pipeable";
+
+// src/internal/json/path.ts
+var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
+var TypeId3 = Symbol.for("effect-qb/JsonPath");
+var makeSegment = (segment) => segment;
+var key = (value) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "key"
+  },
+  kind: "key",
+  key: value
+});
+var index = (value) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "index"
+  },
+  kind: "index",
+  index: value
+});
+var wildcard = () => makeSegment({
+  [SegmentTypeId]: {
+    kind: "wildcard"
+  },
+  kind: "wildcard"
+});
+var slice = (start, end) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "slice"
+  },
+  kind: "slice",
+  start,
+  end
+});
+var descend = () => makeSegment({
+  [SegmentTypeId]: {
+    kind: "descend"
+  },
+  kind: "descend"
+});
+var path = (...segments) => ({
+  [TypeId3]: {
+    segments
+  },
+  segments
+});
+
+// src/internal/json/path-access.ts
+var WrappedTypeId = Symbol.for("effect-qb/JsonPathAccess");
+var accessKinds = new Set([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+]);
+var reservedKeys = new Set([
+  "pipe",
+  "then",
+  "toString",
+  "toJSON",
+  "valueOf",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "inspect",
+  "schema",
+  "metadata",
+  "columns",
+  "name"
+]);
+var isObjectLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isExpression = (value) => isObjectLike(value) && (TypeId in value);
+var isJsonExpression = (value) => {
+  if (!isExpression(value)) {
+    return false;
+  }
+  const dbType = value[TypeId].dbType;
+  return dbType.kind === "json" || dbType.kind === "jsonb" || dbType.variant === "json" || dbType.variant === "jsonb";
+};
+var isWrapped = (value) => value[WrappedTypeId] === true;
+var normalizeSegment = (segment) => {
+  switch (segment.kind) {
+    case "key":
+      return key(segment.key);
+    case "index":
+      return index(segment.index);
+    case "wildcard":
+      return wildcard();
+    case "slice":
+      return slice(segment.start, segment.end);
+    case "descend":
+      return descend();
+  }
+};
+var accessPathOf = (value) => {
+  const segments = [];
+  let base = value;
+  while (isExpression(base)) {
+    const ast = base[TypeId2];
+    if (ast === undefined || typeof ast.kind !== "string" || !accessKinds.has(ast.kind) || !isExpression(ast.base) || !Array.isArray(ast.segments)) {
+      break;
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment));
+    base = ast.base;
+  }
+  return { base, segments };
+};
+var isIntegerProperty = (property) => /^(?:-?(?:0|[1-9][0-9]*))$/.test(property);
+var jsonAccessKind = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index") ? segments.length === 1 ? "jsonGet" : "jsonPath" : "jsonTraverse";
+var makeExpression = (state, ast) => {
+  const expression = Object.create(null);
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments(expression, arguments);
+    }
+  });
+  expression[TypeId] = state;
+  expression[TypeId2] = ast;
+  return expression;
+};
+var makePathExpression = (value, segment) => {
+  const access = accessPathOf(value);
+  const segments = [...access.segments, normalizeSegment(segment)];
+  const base = access.base;
+  const baseState = base[TypeId];
+  return withJsonPathAccess(makeExpression({
+    ...baseState,
+    runtime: undefined,
+    nullability: undefined
+  }, {
+    kind: jsonAccessKind(segments),
+    base,
+    segments
+  }));
+};
+var pathProxyHandler = {
+  get(target, property, receiver) {
+    if (typeof property === "symbol") {
+      return Reflect.get(target, property, receiver);
+    }
+    if (Reflect.has(target, property) || reservedKeys.has(property)) {
+      return Reflect.get(target, property, receiver);
+    }
+    const segment = isIntegerProperty(property) ? index(Number(property)) : key(property);
+    return makePathExpression(target, segment);
+  },
+  has(target, property) {
+    return Reflect.has(target, property);
+  }
+};
+var withJsonPathAccess = (value) => {
+  if (!isObjectLike(value) || !isJsonExpression(value) || isWrapped(value)) {
+    return value;
+  }
+  const proxy = new Proxy(value, pathProxyHandler);
+  Object.defineProperty(proxy, WrappedTypeId, {
+    configurable: false,
+    value: true
+  });
+  return proxy;
+};
+
 // src/internal/column-state.ts
 var ColumnTypeId = Symbol.for("effect-qb/Column");
 var BoundColumnTypeId = Symbol.for("effect-qb/BoundColumn");
 var ColumnProto = {
   pipe() {
-    return pipeArguments(this, arguments);
+    return pipeArguments2(this, arguments);
   }
 };
 var attachPipe = (value) => {
@@ -70,7 +239,7 @@ var attachPipe = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments(value, arguments);
+      return pipeArguments2(value, arguments);
     }
   });
   return value;
@@ -107,7 +276,7 @@ var makeColumnDefinition = (schema, metadata) => {
     identity: metadata.identity,
     enum: metadata.enum
   };
-  return column;
+  return withJsonPathAccess(column);
 };
 var remapColumnDefinition = (column, options = {}) => {
   const schema = options.schema ?? column.schema;
@@ -149,7 +318,7 @@ var remapColumnDefinition = (column, options = {}) => {
   if (BoundColumnTypeId in column) {
     next[BoundColumnTypeId] = column[BoundColumnTypeId];
   }
-  return next;
+  return withJsonPathAccess(next);
 };
 var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casing) => {
   const brandName = `${tableName}.${columnName}`;
@@ -182,7 +351,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casi
     schemaName,
     casing
   };
-  return bound;
+  return withJsonPathAccess(bound);
 };
 
 // src/internal/column.ts
@@ -267,7 +436,7 @@ var array = (options) => (column) => remapColumnDefinition(column, {
     ddlType: `${column.metadata.ddlType ?? column.metadata.dbType.kind}[]`
   }
 });
-function index(arg) {
+function index2(arg) {
   if (isColumnDefinitionValue(arg)) {
     return mapColumn(arg, {
       ...arg.metadata,
@@ -331,7 +500,7 @@ var enrichDbType = (datatypes, dbType) => {
 
 // src/internal/runtime/value.ts
 import * as Schema3 from "effect/Schema";
-var brandString = (pattern2, brand5) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand5));
+var brandString = (pattern, brand5) => Schema3.String.pipe(Schema3.check(Schema3.isPattern(pattern)), Schema3.brand(brand5));
 var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
 var isValidLocalDateString = (value) => {
   const match = localDatePattern.exec(value);
@@ -384,11 +553,11 @@ var isValidInstantString = (value) => {
   const match = instantPattern.exec(value);
   return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]) && isValidOffset(match[3]);
 };
-var LocalDateStringSchema = Schema3.String.pipe(Schema3.pattern(localDatePattern), Schema3.filter(isValidLocalDateString), Schema3.brand("LocalDateString"));
-var LocalTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localTimePattern), Schema3.filter(isValidLocalTimeString), Schema3.brand("LocalTimeString"));
-var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.pattern(offsetTimePattern), Schema3.filter(isValidOffsetTimeString), Schema3.brand("OffsetTimeString"));
-var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localDateTimePattern), Schema3.filter(isValidLocalDateTimeString), Schema3.brand("LocalDateTimeString"));
-var InstantStringSchema = Schema3.String.pipe(Schema3.pattern(instantPattern), Schema3.filter(isValidInstantString), Schema3.brand("InstantString"));
+var LocalDateStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDatePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateString(value))), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalTimeString(value))), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(offsetTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidOffsetTimeString(value))), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDateTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateTimeString(value))), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(instantPattern)), Schema3.check(Schema3.makeFilter((value) => isValidInstantString(value))), Schema3.brand("InstantString"));
 var YearStringSchema = brandString(/^\d{4}$/, "YearString");
 var canonicalizeBigIntString = (input) => {
   const trimmed = input.trim();
@@ -428,22 +597,790 @@ var isCanonicalDecimalString = (value) => {
     return false;
   }
 };
-var BigIntStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalBigIntString), Schema3.brand("BigIntString"));
-var DecimalStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalDecimalString), Schema3.brand("DecimalString"));
-var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
-  key: Schema3.String,
-  value: JsonValueSchema
-})));
-var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null);
-
-// src/standard/datatypes/index.ts
-var exports_datatypes = {};
-__export(exports_datatypes, {
-  standardDatatypes: () => standardDatatypes
-});
-
-// src/standard/datatypes/spec.ts
-var standardDatatypeFamilies = {
+var BigIntStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalBigIntString(value))), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalDecimalString(value))), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null,
+  Schema3.Array(JsonValueSchema),
+  Schema3.Record(Schema3.String, JsonValueSchema)
+]));
+var JsonPrimitiveSchema = Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null
+]);
+
+// src/standard/datatypes/index.ts
+var exports_datatypes = {};
+__export(exports_datatypes, {
+  standardDatatypes: () => standardDatatypes
+});
+
+// src/internal/datatypes/matrix.ts
+var portableDatatypeFamilies = {
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "char", "varchar", "text"],
+    traits: {
+      textual: true
+    }
+  },
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "integer",
+      "real",
+      "boolean",
+      "date",
+      "time",
+      "datetime",
+      "interval",
+      "uuid",
+      "json",
+      "blob",
+      "binary",
+      "array",
+      "range",
+      "multirange",
+      "record",
+      "enum",
+      "set",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["uuid", "text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+};
+var portableDatatypeKinds = {
+  uuid: { family: "uuid", runtime: "string" },
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+};
+var portableDatatypeKeys = Object.keys(portableDatatypeKinds);
+var portableDatatypeDdlTypeByDialect = {
+  standard: {
+    uuid: "uuid",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "blob"
+  },
+  postgres: {
+    uuid: "uuid",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "timestamp",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "bytea"
+  },
+  mysql: {
+    uuid: "char(36)",
+    text: "text",
+    varchar: "varchar(255)",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "blob"
+  },
+  sqlite: {
+    uuid: "text",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "datetime",
+    json: "json",
+    blob: "blob"
+  }
+};
+var portableDatatypeCastTypeByDialect = {
+  standard: portableDatatypeDdlTypeByDialect.standard,
+  postgres: portableDatatypeDdlTypeByDialect.postgres,
+  mysql: {
+    ...portableDatatypeDdlTypeByDialect.mysql,
+    uuid: "char(36)",
+    text: "char",
+    varchar: "char",
+    char: "char",
+    int: "signed",
+    integer: "signed",
+    bigint: "signed",
+    numeric: "decimal",
+    decimal: "decimal",
+    boolean: "unsigned",
+    datetime: "datetime",
+    timestamp: "datetime",
+    blob: "binary"
+  },
+  sqlite: {
+    ...portableDatatypeDdlTypeByDialect.sqlite,
+    uuid: "text",
+    int: "integer",
+    timestamp: "datetime"
+  }
+};
+var hasOwn = (value, key2) => Object.prototype.hasOwnProperty.call(value, key2);
+var renderPortableDatatypeDdlType = (dialect, kind) => {
+  if (!hasOwn(portableDatatypeDdlTypeByDialect, dialect)) {
+    return;
+  }
+  const byKind = portableDatatypeDdlTypeByDialect[dialect];
+  return hasOwn(byKind, kind) ? byKind[kind] : undefined;
+};
+var renderPortableDatatypeCastType = (dialect, kind) => {
+  if (!hasOwn(portableDatatypeCastTypeByDialect, dialect)) {
+    return;
+  }
+  const byKind = portableDatatypeCastTypeByDialect[dialect];
+  return hasOwn(byKind, kind) ? byKind[kind] : undefined;
+};
+var postgresDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  interval: {
+    compareGroup: "interval",
+    castTargets: ["interval", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  xml: {
+    compareGroup: "xml",
+    castTargets: ["xml", "text"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  oid: {
+    compareGroup: "oid",
+    castTargets: ["oid", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  identifier: {
+    compareGroup: "identifier",
+    castTargets: ["identifier", "text"],
+    traits: {}
+  },
+  network: {
+    compareGroup: "network",
+    castTargets: ["network", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  textsearch: {
+    compareGroup: "textsearch",
+    castTargets: ["textsearch", "text"],
+    traits: {}
+  },
+  range: {
+    compareGroup: "range",
+    castTargets: ["range", "text"],
+    traits: {}
+  },
+  multirange: {
+    compareGroup: "multirange",
+    castTargets: ["multirange", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  record: {
+    compareGroup: "record",
+    castTargets: ["record", "text"],
+    traits: {}
+  },
+  array: {
+    compareGroup: "array",
+    castTargets: ["array", "text"],
+    traits: {}
+  },
+  money: {
+    compareGroup: "money",
+    castTargets: ["money", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {}
+  }
+};
+var postgresDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  citext: { family: "text", runtime: "string" },
+  name: { family: "text", runtime: "string" },
+  uuid: { family: "uuid", runtime: "string" },
+  int2: { family: "numeric", runtime: "number" },
+  int4: { family: "numeric", runtime: "number" },
+  int8: { family: "numeric", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  float4: { family: "numeric", runtime: "number" },
+  float8: { family: "numeric", runtime: "number" },
+  money: { family: "money", runtime: "number" },
+  bool: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  timetz: { family: "time", runtime: "offsetTime" },
+  timestamp: { family: "timestamp", runtime: "localDateTime" },
+  timestamptz: { family: "timestamp", runtime: "instant" },
+  interval: { family: "interval", runtime: "string" },
+  bytea: { family: "binary", runtime: "bytes" },
+  json: { family: "json", runtime: "json" },
+  jsonb: { family: "json", runtime: "json" },
+  xml: { family: "xml", runtime: "string" },
+  bit: { family: "bit", runtime: "string" },
+  varbit: { family: "bit", runtime: "string" },
+  oid: { family: "oid", runtime: "number" },
+  xid: { family: "oid", runtime: "number" },
+  xid8: { family: "oid", runtime: "bigintString" },
+  cid: { family: "oid", runtime: "number" },
+  tid: { family: "identifier", runtime: "string" },
+  regclass: { family: "identifier", runtime: "string" },
+  regtype: { family: "identifier", runtime: "string" },
+  regproc: { family: "identifier", runtime: "string" },
+  regprocedure: { family: "identifier", runtime: "string" },
+  regoper: { family: "identifier", runtime: "string" },
+  regoperator: { family: "identifier", runtime: "string" },
+  regconfig: { family: "identifier", runtime: "string" },
+  regdictionary: { family: "identifier", runtime: "string" },
+  pg_lsn: { family: "identifier", runtime: "string" },
+  txid_snapshot: { family: "identifier", runtime: "string" },
+  inet: { family: "network", runtime: "string" },
+  cidr: { family: "network", runtime: "string" },
+  macaddr: { family: "network", runtime: "string" },
+  macaddr8: { family: "network", runtime: "string" },
+  point: { family: "spatial", runtime: "unknown" },
+  line: { family: "spatial", runtime: "unknown" },
+  lseg: { family: "spatial", runtime: "unknown" },
+  box: { family: "spatial", runtime: "unknown" },
+  path: { family: "spatial", runtime: "unknown" },
+  polygon: { family: "spatial", runtime: "unknown" },
+  circle: { family: "spatial", runtime: "unknown" },
+  tsvector: { family: "textsearch", runtime: "string" },
+  tsquery: { family: "textsearch", runtime: "string" },
+  int4range: { family: "range", runtime: "unknown" },
+  int8range: { family: "range", runtime: "unknown" },
+  numrange: { family: "range", runtime: "unknown" },
+  tsrange: { family: "range", runtime: "unknown" },
+  tstzrange: { family: "range", runtime: "unknown" },
+  daterange: { family: "range", runtime: "unknown" },
+  int4multirange: { family: "multirange", runtime: "unknown" },
+  int8multirange: { family: "multirange", runtime: "unknown" },
+  nummultirange: { family: "multirange", runtime: "unknown" },
+  tsmultirange: { family: "multirange", runtime: "unknown" },
+  tstzmultirange: { family: "multirange", runtime: "unknown" },
+  datemultirange: { family: "multirange", runtime: "unknown" }
+};
+var postgresSpecificDatatypeKeys = [
+  "int2",
+  "int4",
+  "int8",
+  "float4",
+  "float8",
+  "money",
+  "bool",
+  "timetz",
+  "timestamptz",
+  "interval",
+  "bytea",
+  "citext",
+  "name",
+  "jsonb",
+  "xml",
+  "bit",
+  "varbit",
+  "oid",
+  "xid",
+  "xid8",
+  "cid",
+  "tid",
+  "regclass",
+  "regtype",
+  "regproc",
+  "regprocedure",
+  "regoper",
+  "regoperator",
+  "regconfig",
+  "regdictionary",
+  "pg_lsn",
+  "txid_snapshot",
+  "inet",
+  "cidr",
+  "macaddr",
+  "macaddr8",
+  "point",
+  "line",
+  "lseg",
+  "box",
+  "path",
+  "polygon",
+  "circle",
+  "tsvector",
+  "tsquery",
+  "int4range",
+  "int8range",
+  "numrange",
+  "tsrange",
+  "tstzrange",
+  "daterange",
+  "int4multirange",
+  "int8multirange",
+  "nummultirange",
+  "tsmultirange",
+  "tstzmultirange",
+  "datemultirange"
+];
+var mysqlDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "datetime",
+      "timestamp",
+      "year",
+      "binary",
+      "json",
+      "bit",
+      "enum",
+      "set",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "datetime", "timestamp", "year", "bit"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "datetime", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "datetime", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "datetime", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  year: {
+    compareGroup: "year",
+    castTargets: ["year", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  set: {
+    compareGroup: "set",
+    castTargets: ["set", "text"],
+    traits: {
+      textual: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "bit",
+      "date",
+      "time",
+      "datetime",
+      "timestamp",
+      "year",
+      "binary",
+      "json",
+      "spatial",
+      "enum",
+      "set",
+      "null"
+    ],
+    traits: {}
+  }
+};
+var mysqlDatatypeKinds = {
+  char: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  tinytext: { family: "text", runtime: "string" },
+  text: { family: "text", runtime: "string" },
+  mediumtext: { family: "text", runtime: "string" },
+  longtext: { family: "text", runtime: "string" },
+  tinyint: { family: "numeric", runtime: "number" },
+  smallint: { family: "numeric", runtime: "number" },
+  mediumint: { family: "numeric", runtime: "number" },
+  int: { family: "numeric", runtime: "number" },
+  integer: { family: "numeric", runtime: "number" },
+  bigint: { family: "numeric", runtime: "bigintString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  dec: { family: "numeric", runtime: "decimalString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  fixed: { family: "numeric", runtime: "decimalString" },
+  float: { family: "numeric", runtime: "number" },
+  double: { family: "numeric", runtime: "number" },
+  real: { family: "numeric", runtime: "number" },
+  bool: { family: "boolean", runtime: "boolean" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  bit: { family: "bit", runtime: "string" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "timestamp", runtime: "localDateTime" },
+  year: { family: "year", runtime: "year" },
+  binary: { family: "binary", runtime: "bytes" },
+  varbinary: { family: "binary", runtime: "bytes" },
+  tinyblob: { family: "binary", runtime: "bytes" },
+  blob: { family: "binary", runtime: "bytes" },
+  mediumblob: { family: "binary", runtime: "bytes" },
+  longblob: { family: "binary", runtime: "bytes" },
+  json: { family: "json", runtime: "json" },
+  geometry: { family: "spatial", runtime: "unknown" },
+  point: { family: "spatial", runtime: "unknown" },
+  linestring: { family: "spatial", runtime: "unknown" },
+  polygon: { family: "spatial", runtime: "unknown" },
+  multipoint: { family: "spatial", runtime: "unknown" },
+  multilinestring: { family: "spatial", runtime: "unknown" },
+  multipolygon: { family: "spatial", runtime: "unknown" },
+  geometrycollection: { family: "spatial", runtime: "unknown" },
+  enum: { family: "enum", runtime: "string" },
+  set: { family: "set", runtime: "string" }
+};
+var mysqlSpecificDatatypeKeys = [
+  "tinytext",
+  "mediumtext",
+  "longtext",
+  "tinyint",
+  "smallint",
+  "mediumint",
+  "dec",
+  "fixed",
+  "float",
+  "double",
+  "bool",
+  "bit",
+  "year",
+  "binary",
+  "varbinary",
+  "tinyblob",
+  "mediumblob",
+  "longblob",
+  "geometry",
+  "point",
+  "linestring",
+  "polygon",
+  "multipoint",
+  "multilinestring",
+  "multipolygon",
+  "geometrycollection"
+];
+var sqliteDatatypeFamilies = {
   text: {
     compareGroup: "text",
     castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
@@ -515,7 +1452,7 @@ var standardDatatypeFamilies = {
     traits: {}
   }
 };
-var standardDatatypeKinds = {
+var sqliteDatatypeKinds = {
   text: { family: "text", runtime: "string" },
   varchar: { family: "text", runtime: "string" },
   char: { family: "text", runtime: "string" },
@@ -535,6 +1472,15 @@ var standardDatatypeKinds = {
   json: { family: "json", runtime: "json" },
   blob: { family: "blob", runtime: "bytes" }
 };
+var sqliteSpecificDatatypeKeys = [
+  "clob",
+  "double"
+];
+var pickDatatypeConstructors = (module, keys) => Object.fromEntries(keys.map((key2) => [key2, module[key2]]));
+
+// src/standard/datatypes/spec.ts
+var standardDatatypeFamilies = portableDatatypeFamilies;
+var standardDatatypeKinds = portableDatatypeKinds;
 
 // src/standard/datatypes/index.ts
 var withMetadata = (kind) => {
@@ -547,6 +1493,7 @@ var withMetadata = (kind) => {
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: familySpec.implicitTargets,
     traits: familySpec?.traits
   };
 };
@@ -577,8 +1524,7 @@ standardDatatypeModule.json = () => ({
   }
 });
 var standardDatatypes = {
-  ...standardDatatypeModule,
-  float8: () => withMetadata("real")
+  ...standardDatatypeModule
 };
 
 // src/standard/column.ts
@@ -597,8 +1543,8 @@ var renderNumericDdlType = (kind, options) => {
   }
   return options.scale === undefined ? `${kind}(${options.precision})` : `${kind}(${options.precision},${options.scale})`;
 };
-var boundedString = (length) => length === undefined ? Schema4.String : Schema4.String.pipe(Schema4.maxLength(length));
-var finiteNumber = Schema4.Number.pipe(Schema4.finite());
+var boundedString = (length) => length === undefined ? Schema4.String : Schema4.String.check(Schema4.isMaxLength(length));
+var finiteNumber = Schema4.Number.check(Schema4.isFinite());
 var custom = (schema2, dbType) => makeColumnDefinition(schema2, {
   dbType: enrichDbType(standardDatatypes, dbType),
   nullable: false,
@@ -610,7 +1556,7 @@ var custom = (schema2, dbType) => makeColumnDefinition(schema2, {
   ddlType: undefined,
   identity: undefined
 });
-var uuid = () => primitive(Schema4.UUID, standardDatatypes.uuid());
+var uuid = () => primitive(Schema4.String.check(Schema4.isUUID()), standardDatatypes.uuid());
 var text = () => primitive(Schema4.String, standardDatatypes.text());
 var varchar = (length) => makeColumnDefinition(boundedString(length), {
   dbType: standardDatatypes.varchar(),
@@ -620,7 +1566,7 @@ var varchar = (length) => makeColumnDefinition(boundedString(length), {
   primaryKey: false,
   unique: false,
   references: undefined,
-  ddlType: length === undefined ? "varchar" : `varchar(${length})`,
+  ddlType: length === undefined ? undefined : `varchar(${length})`,
   identity: undefined
 });
 var char = (length = 1) => makeColumnDefinition(boundedString(length), {
@@ -653,7 +1599,7 @@ var date = () => primitive(LocalDateStringSchema, standardDatatypes.date());
 var time = () => primitive(LocalTimeStringSchema, standardDatatypes.time());
 var datetime = () => primitive(LocalDateTimeStringSchema, standardDatatypes.datetime());
 var timestamp = () => primitive(LocalDateTimeStringSchema, standardDatatypes.timestamp());
-var blob = () => primitive(Schema4.Uint8ArrayFromSelf, standardDatatypes.blob());
+var blob = () => primitive(Schema4.Uint8Array, standardDatatypes.blob());
 var json = (schema2) => makeColumnDefinition(schema2, {
   dbType: { ...standardDatatypes.json(), variant: "json" },
   nullable: false,
@@ -674,165 +1620,33 @@ var generated2 = generated;
 var driverValueMapping2 = driverValueMapping;
 var references2 = references;
 var schema2 = schema;
-// src/standard/function/index.ts
-var exports_function = {};
-__export(exports_function, {
-  window: () => exports_window,
-  upper: () => upper,
-  temporal: () => exports_temporal,
-  string: () => exports_string,
-  rowNumber: () => rowNumber,
-  rank: () => rank,
-  over: () => over,
-  now: () => now,
-  min: () => min,
-  max: () => max,
-  lower: () => lower,
-  localTimestamp: () => localTimestamp,
-  localTime: () => localTime,
-  denseRank: () => denseRank,
-  currentTimestamp: () => currentTimestamp,
-  currentTime: () => currentTime,
-  currentDate: () => currentDate,
-  count: () => count,
-  core: () => exports_core,
-  concat: () => concat,
-  coalesce: () => coalesce,
-  call: () => call,
-  aggregate: () => exports_aggregate
-});
-
-// src/standard/function/core.ts
-var exports_core = {};
-__export(exports_core, {
-  coalesce: () => coalesce,
-  call: () => call
-});
-
-// src/standard/query.ts
-var exports_query = {};
-__export(exports_query, {
-  withRecursive: () => withRecursive_,
-  with: () => with_,
-  where: () => where,
-  values: () => exportedValues,
-  upsert: () => upsert,
-  upper: () => upper,
-  update: () => update,
-  unnest: () => exportedUnnest,
-  union_query_capabilities: () => union_query_capabilities,
-  unionAll: () => unionAll,
-  union: () => union,
-  type: () => type,
-  truncate: () => truncate,
-  transaction: () => transaction,
-  select: () => exportedSelect,
-  scalar: () => scalar,
-  savepoint: () => savepoint,
-  rowNumber: () => rowNumber,
-  rollbackTo: () => rollbackTo,
-  rollback: () => rollback,
-  rightJoin: () => rightJoin,
-  returning: () => returning,
-  releaseSavepoint: () => releaseSavepoint,
-  regexNotMatch: () => regexNotMatch,
-  regexNotIMatch: () => regexNotIMatch,
-  regexMatch: () => regexMatch,
-  regexIMatch: () => regexIMatch,
-  rank: () => rank,
-  overlaps: () => overlaps,
-  over: () => over,
-  orderBy: () => orderBy,
-  or: () => or,
-  onConflict: () => onConflict,
-  offset: () => offset,
-  notIn: () => notIn,
-  not: () => not,
-  neq: () => neq,
-  min: () => min,
-  merge: () => merge2,
-  max: () => max,
-  match: () => match,
-  lte: () => lte,
-  lt: () => lt,
-  lower: () => lower,
-  lock: () => lock,
-  literal: () => literal,
-  limit: () => limit,
-  like: () => like,
-  leftJoin: () => leftJoin,
-  lateral: () => lateral,
-  isNull: () => isNull,
-  isNotNull: () => isNotNull,
-  isNotDistinctFrom: () => isNotDistinctFrom,
-  isDistinctFrom: () => isDistinctFrom,
-  intersectAll: () => intersectAll,
-  intersect: () => intersect,
-  insert: () => exportedInsert,
-  innerJoin: () => innerJoin,
-  inSubquery: () => inSubquery,
-  in: () => in_,
-  ilike: () => ilike,
-  having: () => having,
-  gte: () => gte,
-  gt: () => gt,
-  groupBy: () => groupBy,
-  fullJoin: () => fullJoin,
-  from: () => exportedFrom,
-  exists: () => exists,
-  excluded: () => excluded,
-  exceptAll: () => exceptAll,
-  except: () => except,
-  eq: () => eq,
-  dropTable: () => dropTable,
-  dropIndex: () => dropIndex,
-  distinct: () => distinct,
-  denseRank: () => denseRank,
-  delete: () => delete_,
-  crossJoin: () => crossJoin,
-  createTable: () => createTable,
-  createIndex: () => createIndex,
-  count: () => count,
-  contains: () => contains,
-  containedBy: () => containedBy,
-  concat: () => concat,
-  compareAny: () => compareAny,
-  compareAll: () => compareAll,
-  commit: () => commit,
-  column: () => column,
-  collate: () => collate,
-  coalesce: () => coalesce,
-  cast: () => cast,
-  case: () => case_,
-  call: () => call,
-  between: () => between,
-  as: () => as,
-  any: () => any_,
-  and: () => and,
-  all: () => all_
+// src/standard/cast.ts
+var exports_cast = {};
+__export(exports_cast, {
+  to: () => to
 });
 
 // src/internal/standard-dsl.ts
-import { pipeArguments as pipeArguments6 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments7 } from "effect/Pipeable";
 import * as Schema6 from "effect/Schema";
 
 // src/internal/row-set.ts
 var exports_row_set = {};
 __export(exports_row_set, {
-  TypeId: () => TypeId3
+  TypeId: () => TypeId4
 });
-var TypeId3 = Symbol.for("effect-qb/Plan");
+var TypeId4 = Symbol.for("effect-qb/Plan");
 
 // src/internal/table.ts
-import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 
 // src/internal/schema-expression.ts
 import { parse, toSql } from "pgsql-ast-parser";
-import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
-var TypeId4 = Symbol.for("effect-qb/SchemaExpression");
+import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
+var TypeId5 = Symbol.for("effect-qb/SchemaExpression");
 var SchemaExpressionProto = {
   pipe() {
-    return pipeArguments2(this, arguments);
+    return pipeArguments3(this, arguments);
   }
 };
 var attachPipe2 = (value) => {
@@ -840,35 +1654,35 @@ var attachPipe2 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments2(value, arguments);
+      return pipeArguments3(value, arguments);
     }
   });
   return value;
 };
-var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId4 in value);
+var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId5 in value);
 var fromAst = (ast) => {
   const expression = attachPipe2(Object.create(SchemaExpressionProto));
-  expression[TypeId4] = {
+  expression[TypeId5] = {
     ast
   };
   return expression;
 };
 var fromSql = (sql) => {
   const expression = attachPipe2(Object.create(SchemaExpressionProto));
-  expression[TypeId4] = {
+  expression[TypeId5] = {
     sql: sql.trim()
   };
   return expression;
 };
 var parseExpression = (sql) => fromAst(parse(sql, "expr"));
 var toAst = (expression) => {
-  const ast = expression[TypeId4].ast;
+  const ast = expression[TypeId5].ast;
   if (ast !== undefined) {
     return ast;
   }
   return parse(render(expression), "expr");
 };
-var render = (expression) => expression[TypeId4].sql ?? toSql.expr(toAst(expression));
+var render = (expression) => expression[TypeId5].sql ?? toSql.expr(toAst(expression));
 var normalize = (expression) => (() => {
   const sql = render(expression);
   try {
@@ -963,7 +1777,7 @@ var collectInlineOptions = (fields) => {
   return options;
 };
 var resolvePrimaryKeyColumns = (fields, declaredOptions) => {
-  const inline = Object.entries(fields).filter(([, column]) => column.metadata.primaryKey).map(([key]) => key);
+  const inline = Object.entries(fields).filter(([, column]) => column.metadata.primaryKey).map(([key2]) => key2);
   const explicit = declaredOptions.flatMap((option) => {
     if (typeof option !== "object" || option === null || !("kind" in option) || option.kind !== "primaryKey") {
       return [];
@@ -989,8 +1803,8 @@ var validateOptions = (tableName, fields, options) => {
       case "foreignKey": {
         if (option.kind === "index") {
           const keys = Array.isArray(option.keys) ? option.keys : [];
-          for (const key of keys) {
-            if (typeof key !== "object" || key === null || !("kind" in key)) {
+          for (const key2 of keys) {
+            if (typeof key2 !== "object" || key2 === null || !("kind" in key2)) {
               continue;
             }
           }
@@ -1037,10 +1851,10 @@ var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeyS
 var deriveSchema = (variant, tableName, fields, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
   const structFields = {};
-  for (const [key, column] of Object.entries(fields)) {
-    const schema3 = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+  for (const [key2, column] of Object.entries(fields)) {
+    const schema3 = fieldSchemaForVariant(variant, column, tableName, key2, primaryKeySet);
     if (schema3 !== undefined) {
-      structFields[key] = schema3;
+      structFields[key2] = schema3;
     }
   }
   return Schema5.Struct(structFields);
@@ -1050,7 +1864,7 @@ var deriveInsertSchema = (tableName, fields, primaryKeyColumns) => deriveSchema(
 var deriveUpdateSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("update", tableName, fields, primaryKeyColumns);
 
 // src/internal/casing.ts
-var TypeId5 = Symbol.for("effect-qb/Casing");
+var TypeId6 = Symbol.for("effect-qb/Casing");
 var merge = (base, override) => {
   if (base === undefined) {
     return override;
@@ -1091,15 +1905,16 @@ var apply = (style, name) => {
 var applyCategory = (options, category, name) => apply(options?.[category], name);
 
 // src/internal/table.ts
-var TypeId6 = Symbol.for("effect-qb/Table");
+var TypeId7 = Symbol.for("effect-qb/Table");
 var OptionsSymbol = Symbol.for("effect-qb/Table/normalizedOptions");
 var options = Symbol.for("effect-qb/Table/declaredOptions");
 var CacheSymbol = Symbol.for("effect-qb/Table/cache");
 var SchemaCacheSymbol = Symbol.for("effect-qb/Table/schemaCache");
 var DeclaredOptionsSymbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions");
+var ResolveOptionSymbol = Symbol.for("effect-qb/Table/resolveOption");
 var TableProto = {
   pipe() {
-    return pipeArguments3(this, arguments);
+    return pipeArguments4(this, arguments);
   }
 };
 var attachPipe3 = (value) => {
@@ -1107,21 +1922,50 @@ var attachPipe3 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments3(value, arguments);
+      return pipeArguments4(value, arguments);
     }
   });
   return value;
 };
+var conflictArbitersFromOptions = (options2) => options2.flatMap((option) => {
+  if (typeof option !== "object" || option === null) {
+    return [];
+  }
+  if (!("columns" in option) || !Array.isArray(option.columns) || option.columns.length === 0) {
+    return [];
+  }
+  switch (option.kind) {
+    case "primaryKey":
+    case "unique":
+      return [{
+        columns: option.columns,
+        scope: "unconditional",
+        name: option.name,
+        constraint: true
+      }];
+    case "index":
+      return option.unique === true ? [{
+        columns: option.columns,
+        scope: option.predicate === undefined ? "unconditional" : "partial",
+        name: option.name,
+        constraint: false
+      }] : [];
+    default:
+      return [];
+  }
+});
 var buildArtifacts = (name, fields, declaredOptions, schemaName, casing) => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
   validateFieldDialects(name, fields);
   validateOptions(name, fields, declaredOptions);
   const primaryKey3 = resolvePrimaryKeyColumns(fields, declaredOptions);
-  const columns = Object.fromEntries(Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName, casing)]));
+  const conflictArbiters = conflictArbitersFromOptions(normalizedOptions);
+  const columns = Object.fromEntries(Object.entries(fields).map(([key2, column]) => [key2, bindColumn(name, key2, column, name, schemaName, casing)]));
   return {
     columns,
     normalizedOptions,
-    primaryKey: primaryKey3
+    primaryKey: primaryKey3,
+    conflictArbiters
   };
 };
 var getSchemaCache = (table) => {
@@ -1137,7 +1981,7 @@ var getSchemaCache = (table) => {
   return cache;
 };
 var deriveTableSchema = (table, variant) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   switch (variant) {
     case "select":
       return deriveSelectSchema(state.name, state.fields, state.primaryKey);
@@ -1206,16 +2050,17 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   table.name = name;
   table.columns = artifacts.columns;
   defineSchemasGetter(table);
-  table[TypeId6] = {
+  table[TypeId7] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields,
     primaryKey: artifacts.primaryKey,
+    conflictArbiters: artifacts.conflictArbiters,
     kind,
     casing
   };
-  table[TypeId3] = {
+  table[TypeId4] = {
     selection: artifacts.columns,
     required: undefined,
     available: {
@@ -1229,8 +2074,8 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   };
   table[OptionsSymbol] = artifacts.normalizedOptions;
   table[DeclaredOptionsSymbol] = declaredOptions;
-  for (const [key, value] of Object.entries(artifacts.columns)) {
-    Object.defineProperty(table, key, {
+  for (const [key2, value] of Object.entries(artifacts.columns)) {
+    Object.defineProperty(table, key2, {
       enumerable: true,
       value
     });
@@ -1268,13 +2113,14 @@ var ensureClassArtifacts = (self) => {
   if (cached) {
     return cached;
   }
-  const state = self[TypeId6];
+  const state = self[TypeId7];
   const classOptions = self[options];
   const table = applyDeclaredOptions(makeTable(state.name, state.fields, [], state.name, "schema", state.schemaName, state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit", state.casing), classOptions);
   const artifacts = {
     columns: table.columns,
     normalizedOptions: table[OptionsSymbol],
-    primaryKey: table[TypeId6].primaryKey
+    primaryKey: table[TypeId7].primaryKey,
+    conflictArbiters: table[TypeId7].conflictArbiters
   };
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
@@ -1283,42 +2129,58 @@ var ensureClassArtifacts = (self) => {
   return artifacts;
 };
 var appendOption = (table, option) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   return makeTable(state.name, state.fields, [...table[DeclaredOptionsSymbol], option], state.baseName, state.kind, state.schemaName, "explicit", state.casing);
 };
 var makeOption = (option) => {
   return attachPipe3(Object.assign((table, ..._validation) => appendOption(table, option), { option }));
 };
+var makeResolvedOption = (option, resolve) => {
+  return attachPipe3(Object.assign((table, ..._validation) => appendOption(table, resolve(table)), {
+    option,
+    [ResolveOptionSymbol]: resolve
+  }));
+};
 var option = (spec) => makeOption(spec);
+var optionFromTable = (spec, resolve) => makeResolvedOption(spec, resolve);
+var resolveOption = (option2, table) => {
+  const resolve = option2[ResolveOptionSymbol];
+  return resolve === undefined ? option2.option : resolve(table);
+};
+var mapOption = (option2, map) => {
+  const resolve = option2[ResolveOptionSymbol];
+  return resolve === undefined ? makeOption(map(option2.option)) : makeResolvedOption(map(option2.option), (table) => map(resolve(table)));
+};
 function make(name, fields, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
 var withCasing = (table, casing) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   return makeTable(state.name, state.fields, table[DeclaredOptionsSymbol], state.baseName, state.kind, state.schemaName, "explicit", merge(state.casing, casing));
 };
 var withSchema = (table, schemaName, schemaCasing) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   return makeTable(state.name, state.fields, table[DeclaredOptionsSymbol], state.baseName, state.kind, schemaName, "explicit", merge(schemaCasing, state.casing));
 };
 var alias = (table, aliasName) => {
-  const state = table[TypeId6];
-  const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName, state.casing)]));
+  const state = table[TypeId7];
+  const columns = Object.fromEntries(Object.entries(state.fields).map(([key2, column]) => [key2, bindColumn(aliasName, key2, column, state.baseName, state.schemaName, state.casing)]));
   const aliased = attachPipe3(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
   defineSchemasGetter(aliased);
-  aliased[TypeId6] = {
+  aliased[TypeId7] = {
     name: aliasName,
     baseName: state.baseName,
     schemaName: state.schemaName,
     fields: state.fields,
     primaryKey: state.primaryKey,
+    conflictArbiters: state.conflictArbiters,
     kind: "alias",
     casing: state.casing
   };
-  aliased[TypeId3] = {
+  aliased[TypeId4] = {
     selection: columns,
     required: undefined,
     available: {
@@ -1328,12 +2190,12 @@ var alias = (table, aliasName) => {
         baseName: state.baseName
       }
     },
-    dialect: table[TypeId3].dialect
+    dialect: table[TypeId4].dialect
   };
   aliased[OptionsSymbol] = table[OptionsSymbol];
   aliased[DeclaredOptionsSymbol] = table[DeclaredOptionsSymbol];
-  for (const [key, value] of Object.entries(columns)) {
-    Object.defineProperty(aliased, key, {
+  for (const [key2, value] of Object.entries(columns)) {
+    Object.defineProperty(aliased, key2, {
       enumerable: true,
       value
     });
@@ -1352,18 +2214,20 @@ function Class(name, schemaName) {
       static get schemas() {
         return schemasFor(this);
       }
-      static get [TypeId6]() {
+      static get [TypeId7]() {
         const declaredOptions = extractDeclaredOptions(this[options]);
+        const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
         return {
           name,
           baseName: name,
           schemaName: resolvedSchemaName,
           fields,
           primaryKey: resolvePrimaryKeyColumns(fields, collectInlineOptions(fields)),
+          conflictArbiters: conflictArbitersFromOptions(normalizedOptions),
           kind: "schema"
         };
       }
-      static get [TypeId3]() {
+      static get [TypeId4]() {
         const artifacts = ensureClassArtifacts(this);
         return {
           selection: artifacts.columns,
@@ -1382,49 +2246,83 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).normalizedOptions;
       }
       static pipe() {
-        return pipeArguments3(this, arguments);
+        return pipeArguments4(this, arguments);
       }
     }
-    for (const key of Object.keys(fields)) {
-      Object.defineProperty(TableClassBase, key, {
+    for (const key2 of Object.keys(fields)) {
+      Object.defineProperty(TableClassBase, key2, {
         enumerable: true,
         configurable: true,
         get() {
-          return ensureClassArtifacts(this).columns[key];
+          return ensureClassArtifacts(this).columns[key2];
         }
       });
     }
     return TableClassBase;
   };
 }
-var primaryKey3 = (columns) => makeOption({
-  kind: "primaryKey",
-  columns: normalizeColumnList(columns)
-});
-var unique3 = (columns) => makeOption({
-  kind: "unique",
-  columns: normalizeColumnList(columns)
-});
-var index2 = (columns) => makeOption({
-  kind: "index",
-  columns: normalizeColumnList(columns)
-});
-var foreignKey2 = (columns, target, referencedColumns) => makeOption({
-  kind: "foreignKey",
-  columns: normalizeColumnList(columns),
-  references: () => ({
-    tableName: target()[TypeId6].baseName,
-    schemaName: target()[TypeId6].schemaName,
-    casing: target()[TypeId6].casing,
-    columns: normalizeColumnList(referencedColumns),
-    knownColumns: Object.keys(target()[TypeId6].fields).map((key) => key)
-  })
-});
-var check = (name, predicate) => makeOption({
-  kind: "check",
-  name,
-  predicate
-});
+var selectionArray = (selection) => Array.isArray(selection) ? selection : [selection];
+var selectedColumnList = (selection) => selectionArray(selection).map((column) => column[BoundColumnTypeId].columnName);
+var referenceFromSelection = (selection) => {
+  const columns = selectionArray(selection);
+  const first = columns[0];
+  const bound = first[BoundColumnTypeId];
+  return {
+    tableName: bound.baseTableName,
+    schemaName: bound.schemaName,
+    casing: bound.casing,
+    columns: columns.map((column) => column[BoundColumnTypeId].columnName)
+  };
+};
+function primaryKey3(columns) {
+  return makeResolvedOption({
+    kind: "primaryKey",
+    columns: []
+  }, (table) => ({
+    kind: "primaryKey",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function unique3(columns) {
+  return makeResolvedOption({
+    kind: "unique",
+    columns: []
+  }, (table) => ({
+    kind: "unique",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function index3(columns) {
+  return makeResolvedOption({
+    kind: "index",
+    columns: []
+  }, (table) => ({
+    kind: "index",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function foreignKey2(columns, target) {
+  return makeResolvedOption({
+    kind: "foreignKey",
+    columns: [],
+    references: () => referenceFromSelection(target())
+  }, (table) => ({
+    kind: "foreignKey",
+    columns: selectedColumnList(columns(table)),
+    references: () => referenceFromSelection(target())
+  }));
+}
+function check2(name, predicate) {
+  const spec = {
+    kind: "check",
+    name,
+    predicate
+  };
+  return typeof predicate === "function" ? makeResolvedOption(spec, (table) => ({
+    ...spec,
+    predicate: predicate(table)
+  })) : makeOption(spec);
+}
 
 // src/internal/runtime/normalize.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1677,9 +2575,9 @@ var normalizeDbValue = (dbType, value) => {
       throw new Error("Expected a record value");
     }
     const normalized = {};
-    for (const [key, fieldDbType] of Object.entries(dbType.fields)) {
-      if (key in value) {
-        normalized[key] = normalizeDbValue(fieldDbType, value[key]);
+    for (const [key2, fieldDbType] of Object.entries(dbType.fields)) {
+      if (key2 in value) {
+        normalized[key2] = normalizeDbValue(fieldDbType, value[key2]);
       }
     }
     return normalized;
@@ -1736,10 +2634,10 @@ var normalizeDbValue = (dbType, value) => {
 };
 
 // src/internal/query.ts
-import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
 
 // src/internal/query-ast.ts
-var TypeId7 = Symbol.for("effect-qb/QueryAst");
+var TypeId8 = Symbol.for("effect-qb/QueryAst");
 
 // src/internal/predicate/runtime.ts
 var trueFormula = () => ({ kind: "true" });
@@ -1764,17 +2662,17 @@ var cloneContext = (context) => ({
   nonNullKeys: new Set(context.nonNullKeys),
   nullKeys: new Set(context.nullKeys),
   eqLiterals: new Map(context.eqLiterals),
-  neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
-  literalSets: new Map(Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])),
+  neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key2, values]) => [key2, new Set(values)])),
+  literalSets: new Map(Array.from(context.literalSets.entries(), ([key2, values]) => [key2, new Set(values)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
 });
 var freezeContext = (context) => context;
 var columnPredicateKey = (tableName, columnName) => JSON.stringify([tableName, columnName]);
-var columnPredicateKeyParts = (key) => {
-  const jsonSeparator = key.indexOf("#json:");
-  const columnKey = jsonSeparator === -1 ? key : key.slice(0, jsonSeparator);
+var columnPredicateKeyParts = (key2) => {
+  const jsonSeparator = key2.indexOf("#json:");
+  const columnKey = jsonSeparator === -1 ? key2 : key2.slice(0, jsonSeparator);
   try {
     const parsed = JSON.parse(columnKey);
     return Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string" ? [parsed[0], parsed[1]] : undefined;
@@ -1782,59 +2680,59 @@ var columnPredicateKeyParts = (key) => {
     return;
   }
 };
-var sourceNameOfKey = (key) => columnPredicateKeyParts(key)?.[0] ?? key.split(".", 1)[0] ?? key;
-var addSourceName = (context, key) => {
-  context.sourceNames.add(sourceNameOfKey(key));
+var sourceNameOfKey = (key2) => columnPredicateKeyParts(key2)?.[0] ?? key2.split(".", 1)[0] ?? key2;
+var addSourceName = (context, key2) => {
+  context.sourceNames.add(sourceNameOfKey(key2));
 };
-var addNonNull = (context, key) => {
-  addSourceName(context, key);
-  if (context.nullKeys.has(key)) {
+var addNonNull = (context, key2) => {
+  addSourceName(context, key2);
+  if (context.nullKeys.has(key2)) {
     context.contradiction = true;
   }
-  context.nonNullKeys.add(key);
+  context.nonNullKeys.add(key2);
 };
-var addNull = (context, key) => {
-  addSourceName(context, key);
-  if (context.nonNullKeys.has(key)) {
+var addNull = (context, key2) => {
+  addSourceName(context, key2);
+  if (context.nonNullKeys.has(key2)) {
     context.contradiction = true;
   }
-  context.nullKeys.add(key);
+  context.nullKeys.add(key2);
 };
-var addEqLiteral = (context, key, value) => {
-  addNonNull(context, key);
-  const existing = context.eqLiterals.get(key);
+var addEqLiteral = (context, key2, value) => {
+  addNonNull(context, key2);
+  const existing = context.eqLiterals.get(key2);
   if (existing !== undefined && existing !== value) {
     context.contradiction = true;
   }
-  const neqValues = context.neqLiterals.get(key);
+  const neqValues = context.neqLiterals.get(key2);
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
-  const existingSet = context.literalSets.get(key);
+  const existingSet = context.literalSets.get(key2);
   if (existingSet !== undefined && !existingSet.has(value)) {
     context.contradiction = true;
   }
-  context.eqLiterals.set(key, value);
-  context.literalSets.set(key, new Set([value]));
+  context.eqLiterals.set(key2, value);
+  context.literalSets.set(key2, new Set([value]));
 };
-var addNeqLiteral = (context, key, value) => {
-  addNonNull(context, key);
-  if (context.eqLiterals.get(key) === value) {
+var addNeqLiteral = (context, key2, value) => {
+  addNonNull(context, key2);
+  if (context.eqLiterals.get(key2) === value) {
     context.contradiction = true;
   }
-  const values = context.neqLiterals.get(key) ?? new Set;
+  const values = context.neqLiterals.get(key2) ?? new Set;
   values.add(value);
-  context.neqLiterals.set(key, values);
+  context.neqLiterals.set(key2, values);
 };
-var addLiteralSet = (context, key, values) => {
-  addNonNull(context, key);
-  const existingEq = context.eqLiterals.get(key);
+var addLiteralSet = (context, key2, values) => {
+  addNonNull(context, key2);
+  const existingEq = context.eqLiterals.get(key2);
   if (existingEq !== undefined && !values.has(existingEq)) {
     context.contradiction = true;
   }
-  const existing = context.literalSets.get(key);
-  context.literalSets.set(key, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
-  if (context.literalSets.get(key)?.size === 0) {
+  const existing = context.literalSets.get(key2);
+  context.literalSets.set(key2, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
+  if (context.literalSets.get(key2)?.size === 0) {
     context.contradiction = true;
   }
 };
@@ -1916,35 +2814,35 @@ var applyNegativeAtom = (context, atom) => {
 };
 var intersectEqLiterals = (left, right) => {
   const result = new Map;
-  for (const [key, value] of left) {
-    if (right.get(key) === value) {
-      result.set(key, value);
+  for (const [key2, value] of left) {
+    if (right.get(key2) === value) {
+      result.set(key2, value);
     }
   }
   return result;
 };
 var intersectNeqLiterals = (left, right) => {
   const result = new Map;
-  for (const [key, leftValues] of left) {
-    const rightValues = right.get(key);
+  for (const [key2, leftValues] of left) {
+    const rightValues = right.get(key2);
     if (rightValues === undefined) {
       continue;
     }
     const next = new Set(Array.from(leftValues).filter((value) => rightValues.has(value)));
     if (next.size > 0) {
-      result.set(key, next);
+      result.set(key2, next);
     }
   }
   return result;
 };
 var unionLiteralSets = (left, right) => {
   const result = new Map;
-  for (const [key, leftValues] of left) {
-    const rightValues = right.get(key);
+  for (const [key2, leftValues] of left) {
+    const rightValues = right.get(key2);
     if (rightValues === undefined) {
       continue;
     }
-    result.set(key, new Set([...leftValues, ...rightValues]));
+    result.set(key2, new Set([...leftValues, ...rightValues]));
   }
   return result;
 };
@@ -1956,8 +2854,8 @@ var intersectContexts = (left, right) => {
     return cloneContext(left);
   }
   return {
-    nonNullKeys: new Set(Array.from(left.nonNullKeys).filter((key) => right.nonNullKeys.has(key))),
-    nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
+    nonNullKeys: new Set(Array.from(left.nonNullKeys).filter((key2) => right.nonNullKeys.has(key2))),
+    nullKeys: new Set(Array.from(left.nullKeys).filter((key2) => right.nullKeys.has(key2))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
     literalSets: unionLiteralSets(left.literalSets, right.literalSets),
@@ -2048,18 +2946,18 @@ var jsonPathPredicateKeyOfExpression = (value) => {
       if (segments.length === 0 || segments.length > 8) {
         return;
       }
-      const path = [];
+      const path2 = [];
       for (const segment of segments) {
         if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
           return;
         }
-        path.push(segment.key);
+        path2.push(segment.key);
       }
-      if (path.length === 0) {
+      if (path2.length === 0) {
         return;
       }
       const baseKey = columnKeyOfExpression(jsonAst.base);
-      return baseKey === undefined ? undefined : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`;
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path2.map(escapeJsonPathPredicateKeySegment).join(".")}`;
     }
     default:
       return;
@@ -2096,8 +2994,8 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = predicateKeyOfExpression(value);
-  return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
+  const key2 = predicateKeyOfExpression(value);
+  return key2 === undefined ? undefined : atomFormula({ kind: "is-not-null", key: key2 });
 };
 var combineFacts = (left, right) => {
   if (left === undefined) {
@@ -2308,12 +3206,12 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = predicateKeyOfExpression(ast.value);
-      return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
+      const key2 = predicateKeyOfExpression(ast.value);
+      return key2 === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key: key2 });
     }
     case "isNotNull": {
-      const key = predicateKeyOfExpression(ast.value);
-      return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
+      const key2 = predicateKeyOfExpression(ast.value);
+      return key2 === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key: key2 });
     }
     case "not":
       return notFormula(formulaOfExpression(ast.value));
@@ -2334,12 +3232,12 @@ var formulaOfExpression = (value) => {
       if (left === undefined) {
         return falseFormula();
       }
-      const key = predicateKeyOfExpression(left);
+      const key2 = predicateKeyOfExpression(left);
       const literalValues = rest.map((entry) => {
         const entryAst = astOf(entry);
         return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined;
       });
-      return key !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      return key2 !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key: key2, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
@@ -2376,12 +3274,12 @@ var union_query_capabilities = (...values) => [...new Set(values.flatMap((value)
 // src/internal/query.ts
 var ExpressionProto = {
   pipe() {
-    return pipeArguments4(this, arguments);
+    return pipeArguments5(this, arguments);
   }
 };
 var PlanProto = {
   pipe() {
-    return pipeArguments4(this, arguments);
+    return pipeArguments5(this, arguments);
   }
 };
 var QueryTypeId = Symbol.for("effect-qb/Query/internal");
@@ -2394,13 +3292,13 @@ var mergeAggregationManyRuntime = (values) => values.reduce((current, value) =>
 var mergeNullabilityRuntime = (left, right = "never") => left === "always" || right === "always" ? "always" : left === "maybe" || right === "maybe" ? "maybe" : "never";
 var mergeNullabilityManyRuntime = (values) => values.reduce((current, value) => mergeNullabilityRuntime(current, value[TypeId].nullability), "never");
 var mergeManyDependencies = (values) => values.reduce((current, value) => mergeDependencies(current, value[TypeId].dependencies), {});
-var makeExpression = (state, ast) => {
+var makeExpression2 = (state, ast) => {
   const expression = Object.create(ExpressionProto);
   Object.defineProperty(expression, "pipe", {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments4(expression, arguments);
+      return pipeArguments5(expression, arguments);
     }
   });
   expression[TypeId] = {
@@ -2422,11 +3320,11 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments4(plan, arguments);
+      return pipeArguments5(plan, arguments);
     }
   });
-  plan[TypeId3] = state;
-  plan[TypeId7] = ast;
+  plan[TypeId4] = state;
+  plan[TypeId8] = ast;
   plan[QueryTypeId] = {
     required: undefined,
     availableNames: undefined,
@@ -2440,7 +3338,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
   };
   return plan;
 };
-var getAst = (plan) => plan[TypeId7];
+var getAst = (plan) => plan[TypeId8];
 var getQueryState = (plan) => plan[QueryTypeId];
 var extractRequiredRuntime = (selection) => {
   const required = new Set;
@@ -2487,8 +3385,8 @@ var presenceWitnessesOfSourceLike = (source) => {
   if (typeof source !== "object" || source === null) {
     return [];
   }
-  if (TypeId6 in source) {
-    collectPresenceWitnesses(source[TypeId3].selection, output);
+  if (TypeId7 in source) {
+    collectPresenceWitnesses(source[TypeId4].selection, output);
     return [...output];
   }
   if ("columns" in source) {
@@ -2500,7 +3398,7 @@ var directAbsentSourceNames = (available, assumptions) => {
   const nullKeys = guaranteedNullKeys(assumptions);
   const absent = new Set;
   for (const [name, source] of Object.entries(available)) {
-    if (source._presenceWitnesses?.some((key) => nullKeys.has(key))) {
+    if (source._presenceWitnesses?.some((key2) => nullKeys.has(key2))) {
       absent.add(name);
       continue;
     }
@@ -2577,51 +3475,6 @@ var resolveImplicationScope = (available, initialAssumptions) => {
   };
 };
 
-// src/internal/json/path.ts
-var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
-var TypeId8 = Symbol.for("effect-qb/JsonPath");
-var makeSegment = (segment) => segment;
-var key = (value) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "key"
-  },
-  kind: "key",
-  key: value
-});
-var index3 = (value) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "index"
-  },
-  kind: "index",
-  index: value
-});
-var wildcard = () => makeSegment({
-  [SegmentTypeId]: {
-    kind: "wildcard"
-  },
-  kind: "wildcard"
-});
-var slice = (start, end) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "slice"
-  },
-  kind: "slice",
-  start,
-  end
-});
-var descend = () => makeSegment({
-  [SegmentTypeId]: {
-    kind: "descend"
-  },
-  kind: "descend"
-});
-var path = (...segments) => ({
-  [TypeId8]: {
-    segments
-  },
-  segments
-});
-
 // src/internal/grouping-key.ts
 var subqueryPlanIds = new WeakMap;
 var nextSubqueryPlanId = 0;
@@ -2655,8 +3508,8 @@ var literalGroupingKey = (value) => {
       return `literal:${JSON.stringify(value)}`;
   }
 };
-var isExpression = (value) => value !== null && typeof value === "object" && (TypeId in value);
-var expressionGroupingKey = (value) => isExpression(value) ? groupingKeyOfExpression(value) : "missing";
+var isExpression2 = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var expressionGroupingKey = (value) => isExpression2(value) ? groupingKeyOfExpression(value) : "missing";
 var requiredExpressionGroupingKey = (_functionName, value) => groupingKeyOfExpression(value);
 var requiredBinaryExpressionGroupingKey = (_functionName, left, right) => `${groupingKeyOfExpression(left)},${groupingKeyOfExpression(right)}`;
 var functionCallArgsGroupingKey = (args) => args.map(groupingKeyOfExpression).join(",");
@@ -2712,7 +3565,7 @@ var jsonPathGroupingKey = (segments) => {
   }
   return segments.map(jsonSegmentGroupingKey).join(",");
 };
-var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var jsonOpaquePathGroupingKey = (value) => {
   if (isJsonPath(value)) {
     return `jsonpath:${jsonPathGroupingKey(value.segments)}`;
@@ -2720,7 +3573,7 @@ var jsonOpaquePathGroupingKey = (value) => {
   if (typeof value === "string") {
     return `jsonpath:${escapeGroupingText(value)}`;
   }
-  if (isExpression(value)) {
+  if (isExpression2(value)) {
     return `jsonpath:${groupingKeyOfExpression(value)}`;
   }
   return "jsonpath:unknown";
@@ -2983,7 +3836,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "createTable",
       select: {},
@@ -3011,7 +3864,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "dropTable",
       select: {},
@@ -3042,7 +3895,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "createIndex",
       select: {},
@@ -3075,7 +3928,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "dropIndex",
       select: {},
@@ -3129,7 +3982,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: sourceBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "insert",
       select: {},
@@ -3149,7 +4002,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "insert", target, insertState);
   };
   const attachInsertSource = (plan, source) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const target = currentQuery.target;
@@ -3189,11 +4042,11 @@ var makeDslMutationRuntime = (ctx) => {
       }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
     }
     const sourcePlan = source;
-    const selection = sourcePlan[TypeId3].selection;
+    const selection = sourcePlan[TypeId4].selection;
     const columns = ctx.normalizeInsertSelectColumns(selection);
     return ctx.makePlan({
       selection: current.selection,
-      required: ctx.currentRequiredList(sourcePlan[TypeId3].required),
+      required: ctx.currentRequiredList(sourcePlan[TypeId4].required),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -3207,7 +4060,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
   };
   const onConflict = (target, options2 = {}) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const insertTarget = currentAst.into.source;
@@ -3251,7 +4104,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required,
       available: ctx.mutationAvailableSources(target),
-      dialect: primaryTarget.source[TypeId3].dialect
+      dialect: primaryTarget.source[TypeId4].dialect
     }, {
       kind: "update",
       select: {},
@@ -3283,7 +4136,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: sourceBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "insert",
       select: {},
@@ -3317,7 +4170,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required: [],
       available: ctx.mutationAvailableSources(target),
-      dialect: primaryTarget.source[TypeId3].dialect
+      dialect: primaryTarget.source[TypeId4].dialect
     }, {
       kind: "delete",
       select: {},
@@ -3338,7 +4191,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "truncate",
       select: {},
@@ -3392,7 +4245,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: usingBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "merge",
       select: {},
@@ -3455,7 +4308,7 @@ var renderMysqlMutationLockMode = (mode, _statement) => {
 var makeDslPlanRuntime = (ctx) => {
   const sourceRequiredList = (source) => typeof source === "object" && source !== null && ("required" in source) ? ctx.currentRequiredList(source.required) : [];
   const buildSetOperation = (kind, all, left, right) => {
-    const leftState = left[TypeId3];
+    const leftState = left[TypeId4];
     const leftAst = ctx.getAst(left);
     const basePlan = leftAst.kind === "set" ? leftAst.setBase ?? left : left;
     const leftOperations = leftAst.kind === "set" ? [...leftAst.setOperations ?? []] : [];
@@ -3463,7 +4316,7 @@ var makeDslPlanRuntime = (ctx) => {
       selection: leftState.selection,
       required: undefined,
       available: {},
-      dialect: leftState.dialect ?? right[TypeId3].dialect
+      dialect: leftState.dialect ?? right[TypeId4].dialect
     }, {
       kind: "set",
       select: leftState.selection,
@@ -3484,7 +4337,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, undefined, undefined, "set");
   };
   const where = (predicate) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const predicateExpression = ctx.toDialectExpression(predicate);
@@ -3503,7 +4356,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
   };
   const from = (source) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     if (currentQuery.statement === "insert") {
@@ -3570,7 +4423,7 @@ var makeDslPlanRuntime = (ctx) => {
     return plan;
   };
   const having = (predicate) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const predicateExpression = ctx.toDialectExpression(predicate);
@@ -3589,7 +4442,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
   };
   const crossJoin = (table) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
@@ -3609,7 +4462,7 @@ var makeDslPlanRuntime = (ctx) => {
       selection: current.selection,
       required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index4, values) => !(name in nextAvailable) && values.indexOf(name) === index4),
       available: nextAvailable,
-      dialect: current.dialect ?? table[TypeId3]?.dialect ?? table.dialect
+      dialect: current.dialect ?? table[TypeId4]?.dialect ?? table.dialect
     }, {
       ...currentAst,
       joins: [...currentAst.joins, {
@@ -3621,7 +4474,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const join = (kind, table, on) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const onExpression = ctx.toDialectExpression(on);
@@ -3663,7 +4516,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, kind === "inner" ? ctx.assumeFormulaTrue(currentQuery.assumptions, onFormula) : currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const orderBy = (value, direction = "asc") => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const expression = ctx.toDialectExpression(value);
@@ -3683,7 +4536,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const lock = (mode, options2 = {}) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     return ctx.makePlan({
@@ -3702,7 +4555,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const distinct = () => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     return ctx.makePlan({
@@ -3716,7 +4569,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const limit = (value) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const expression = ctx.toDialectNumericExpression(value);
@@ -3732,7 +4585,7 @@ var makeDslPlanRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const offset = (value) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const expression = ctx.toDialectNumericExpression(value);
@@ -3830,7 +4683,7 @@ var makeDslQueryRuntime = (ctx) => {
     }, undefined, "read", "select");
   };
   const groupBy = (...values2) => (plan) => {
-    const current = plan[TypeId3];
+    const current = plan[TypeId4];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
     const required = [...values2.flatMap((value) => Object.keys(value[TypeId].dependencies))].filter((name, index4, list) => !(name in current.available) && list.indexOf(name) === index4);
@@ -3846,7 +4699,7 @@ var makeDslQueryRuntime = (ctx) => {
   };
   const returning = (selection) => {
     return (plan) => {
-      const current = plan[TypeId3];
+      const current = plan[TypeId4];
       const currentAst = ctx.getAst(plan);
       const currentQuery = ctx.getQueryState(plan);
       return ctx.makePlan({
@@ -3871,14 +4724,14 @@ var makeDslQueryRuntime = (ctx) => {
 };
 
 // src/internal/derived-table.ts
-import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments6 } from "effect/Pipeable";
 
 // src/internal/projection-alias.ts
 var TypeId9 = Symbol.for("effect-qb/ProjectionAlias");
 
 // src/internal/projections.ts
 var aliasFromPath = (path2) => path2.join("__");
-var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId in value);
+var isExpression3 = (value) => typeof value === "object" && value !== null && (TypeId in value);
 var projectionAliasOf = (expression) => (TypeId9 in expression) ? expression[TypeId9].alias : undefined;
 var pathKeyOf = (path2) => JSON.stringify(path2);
 var formatProjectionPath = (path2) => path2.join(".");
@@ -3887,7 +4740,7 @@ var flattenSelection = (selection, path2 = []) => {
   const fields = [];
   for (const [key2, value] of Object.entries(selection)) {
     const nextPath = [...path2, key2];
-    if (isExpression2(value)) {
+    if (isExpression3(value)) {
       fields.push({
         path: nextPath,
         expression: value,
@@ -3927,7 +4780,7 @@ var validateProjections = (projections) => {
 // src/internal/derived-table.ts
 var DerivedProto = {
   pipe() {
-    return pipeArguments5(this, arguments);
+    return pipeArguments6(this, arguments);
   }
 };
 var attachPipe4 = (value) => {
@@ -3935,7 +4788,7 @@ var attachPipe4 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments5(value, arguments);
+      return pipeArguments6(value, arguments);
     }
   });
   return value;
@@ -3961,7 +4814,7 @@ var reboundedColumns = (plan, alias2) => {
   const projections = flattenSelection(ast.select);
   for (const projection of projections) {
     const expression = projection.expression;
-    setPath(selection, projection.path, makeExpression({
+    setPath(selection, projection.path, makeExpression2({
       runtime: undefined,
       dbType: expression[TypeId].dbType,
       runtimeSchema: expression[TypeId].runtimeSchema,
@@ -3986,7 +4839,7 @@ var makeDerivedSource = (plan, alias2) => {
   derived.kind = "derived";
   derived.name = alias2;
   derived.baseName = alias2;
-  derived.dialect = plan[TypeId3].dialect;
+  derived.dialect = plan[TypeId4].dialect;
   derived.plan = plan;
   derived.required = undefined;
   derived.columns = columns;
@@ -3999,7 +4852,7 @@ var makeCteSource = (plan, alias2, recursive = false) => {
   cte.kind = "cte";
   cte.name = alias2;
   cte.baseName = alias2;
-  cte.dialect = plan[TypeId3].dialect;
+  cte.dialect = plan[TypeId4].dialect;
   cte.plan = plan;
   cte.recursive = recursive;
   cte.required = undefined;
@@ -4013,9 +4866,9 @@ var makeLateralSource = (plan, alias2) => {
   lateral.kind = "lateral";
   lateral.name = alias2;
   lateral.baseName = alias2;
-  lateral.dialect = plan[TypeId3].dialect;
+  lateral.dialect = plan[TypeId4].dialect;
   lateral.plan = plan;
-  lateral.required = currentRequiredList(plan[TypeId3].required);
+  lateral.required = currentRequiredList(plan[TypeId4].required);
   lateral.columns = columns;
   return lateral;
 };
@@ -4024,7 +4877,7 @@ var makeLateralSource = (plan, alias2) => {
 var profile = {
   dialect: "standard",
   textDb: standardDatatypes.text(),
-  numericDb: standardDatatypes.float8(),
+  numericDb: standardDatatypes.real(),
   boolDb: standardDatatypes.boolean(),
   timestampDb: standardDatatypes.timestamp(),
   nullDb: {
@@ -4039,16 +4892,19 @@ var profile = {
 };
 var ValuesInputProto = {
   pipe() {
-    return pipeArguments6(this, arguments);
+    return pipeArguments7(this, arguments);
   }
 };
 var literalSchemaOf = (value) => {
   if (value === null || value instanceof Date) {
     return;
   }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return;
+  }
   return Schema6.Literal(value);
 };
-var literal = (value) => makeExpression({
+var literal = (value) => makeExpression2({
   runtime: undefined,
   dbType: value === null ? profile.nullDb : value instanceof Date ? profile.timestampDb : typeof value === "string" ? profile.textDb : typeof value === "number" ? profile.numericDb : profile.boolDb,
   runtimeSchema: literalSchemaOf(value),
@@ -4060,7 +4916,7 @@ var literal = (value) => makeExpression({
   kind: "literal",
   value
 });
-var column = (name, dbType, nullable3 = false) => makeExpression({
+var column = (name, dbType, nullable3 = false) => makeExpression2({
   runtime: undefined,
   dbType,
   nullability: nullable3 ? "maybe" : "never",
@@ -4084,7 +4940,7 @@ var retargetLiteralExpression = (value, target) => {
     return value;
   }
   const targetState = target[TypeId];
-  return makeExpression({
+  return makeExpression2({
     runtime: value[TypeId].runtime,
     dbType: targetState.dbType,
     runtimeSchema: targetState.runtimeSchema,
@@ -4122,7 +4978,7 @@ var flattenVariadicBooleanExpressions = (kind, values) => {
 };
 var makeVariadicBooleanExpression = (kind, values) => {
   const expressions = flattenVariadicBooleanExpressions(kind, values);
-  const expression = makeExpression({
+  const expression = makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: mergeNullabilityManyRuntime(expressions),
@@ -4146,7 +5002,7 @@ var makeVariadicBooleanExpression = (kind, values) => {
         return makeVariadicBooleanExpression(kind, [...expressions, ...appended]);
       }
       if (operations.every((operation) => typeof operation === "function")) {
-        return pipeArguments6(this, arguments);
+        return pipeArguments7(this, arguments);
       }
       const valuesForMixedPipe = (value) => {
         if (typeof value !== "object" || value === null || !(TypeId in value)) {
@@ -4197,7 +5053,7 @@ var extractRequiredFromDialectNumericInputRuntime = (value) => {
 };
 var buildBinaryPredicate = (left, right, kind, nullability = "maybe") => {
   const [leftExpression, rightExpression] = alignBinaryPredicateExpressions(toDialectExpression(left), toDialectExpression(right));
-  return makeExpression({
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability,
@@ -4214,7 +5070,7 @@ var buildVariadicPredicate = (values, kind) => {
   const expressions = values.map((value) => toDialectExpression(value));
   const [head, ...tail] = expressions;
   const alignedExpressions = head !== undefined && (kind === "in" || kind === "notIn" || kind === "between") ? [head, ...tail.map((value) => retargetLiteralExpression(value, head))] : expressions;
-  return makeExpression({
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "maybe",
@@ -4298,7 +5154,7 @@ var isNotDistinctFrom = (...args) => {
 };
 var isNull = (value) => {
   const expression = toDialectExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "never",
@@ -4312,7 +5168,7 @@ var isNull = (value) => {
 };
 var isNotNull = (value) => {
   const expression = toDialectExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "never",
@@ -4326,7 +5182,7 @@ var isNotNull = (value) => {
 };
 var upper = (value) => {
   const expression = toDialectStringExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: "",
     dbType: profile.textDb,
     nullability: expression[TypeId].nullability,
@@ -4340,7 +5196,7 @@ var upper = (value) => {
 };
 var lower = (value) => {
   const expression = toDialectStringExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: "",
     dbType: profile.textDb,
     nullability: expression[TypeId].nullability,
@@ -4355,7 +5211,7 @@ var lower = (value) => {
 var collate = (value, collation) => {
   const expression = toDialectStringExpression(value);
   const normalizedCollation = typeof collation === "string" ? [collation] : collation;
-  return makeExpression({
+  return makeExpression2({
     runtime: expression[TypeId].runtime,
     dbType: expression[TypeId].dbType,
     nullability: expression[TypeId].nullability,
@@ -4370,7 +5226,7 @@ var collate = (value, collation) => {
 };
 var cast = (value, target) => {
   const expression = toDialectExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: target,
     runtimeSchema: undefined,
@@ -4385,41 +5241,6 @@ var cast = (value, target) => {
     target
   });
 };
-var array2 = (element) => ({
-  dialect: profile.dialect,
-  kind: `${element.kind}[]`,
-  element
-});
-var range = (kind, subtype) => ({
-  dialect: profile.dialect,
-  kind,
-  subtype
-});
-var multirange = (kind, subtype) => ({
-  dialect: profile.dialect,
-  kind,
-  subtype
-});
-var record = (kind, fields) => ({
-  dialect: profile.dialect,
-  kind,
-  fields
-});
-var domain = (kind, base) => ({
-  dialect: profile.dialect,
-  kind,
-  base
-});
-var enum_ = (kind) => ({
-  dialect: profile.dialect,
-  kind,
-  variant: "enum"
-});
-var set = (kind) => ({
-  dialect: profile.dialect,
-  kind,
-  variant: "set"
-});
 var custom2 = (kind) => ({
   dialect: profile.dialect,
   kind
@@ -4430,13 +5251,6 @@ var driverValueMapping3 = (dbType, mapping) => ({
 });
 var type = {
   ...profile.type,
-  array: array2,
-  range,
-  multirange,
-  record,
-  domain,
-  enum: enum_,
-  set,
   custom: custom2,
   driverValueMapping: driverValueMapping3
 };
@@ -4452,21 +5266,21 @@ var isJsonExpressionValue = (value) => isExpressionValue(value) && (() => {
   const dbType = value[TypeId].dbType;
   return dbType.variant === "json" || dbType.kind === "json" || dbType.kind === "jsonb";
 })();
-var isJsonPathValue = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isJsonPathValue = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var normalizeJsonPathInput = (value) => isJsonPathValue(value) ? value.segments : [value];
 var isExactJsonSegmentValue = (segment) => segment.kind === "key" || segment.kind === "index";
 var isExactJsonPathValue = (segments) => segments.every(isExactJsonSegmentValue);
-var buildJsonNodeExpression = (expressions, state, ast) => makeExpression({
+var buildJsonNodeExpression = (expressions, state, ast) => withJsonPathAccess(makeExpression2({
   runtime: state.runtime,
   dbType: state.dbType,
   nullability: state.nullability,
   dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
   kind: mergeAggregationManyRuntime(expressions),
   dependencies: mergeManyDependencies(expressions)
-}, ast);
+}, ast));
 var jsonDbTypeOf = (base) => base[TypeId].dbType;
 var resolveJsonMergeDbType = (..._values) => jsonbDb;
-var makeJsonLiteralExpression = (value, dbType = jsonDb) => makeExpression({
+var makeJsonLiteralExpression = (value, dbType = jsonDb) => withJsonPathAccess(makeExpression2({
   runtime: value,
   dbType,
   nullability: value === null ? "always" : "never",
@@ -4476,7 +5290,7 @@ var makeJsonLiteralExpression = (value, dbType = jsonDb) => makeExpression({
 }, {
   kind: "literal",
   value
-});
+}));
 var wrapJsonExpression = (value, kind, dbType) => buildJsonNodeExpression([value], {
   runtime: undefined,
   dbType,
@@ -4719,6 +5533,7 @@ var jsonBuildObject = jsonBuildObjectAs(jsonDb);
 var jsonBuildArray = jsonBuildArrayAs(jsonDb);
 var jsonbBuildObject = jsonBuildObjectAs(jsonbDb);
 var jsonbBuildArray = jsonBuildArrayAs(jsonbDb);
+var jsonToJson = (value) => toJsonValueExpression(value, "jsonToJson", jsonDb);
 var jsonToJsonb = (value) => toJsonValueExpression(value, "jsonToJsonb", jsonbDb);
 var jsonTypeOf = (base) => buildJsonNodeExpression([base], {
   runtime: undefined,
@@ -4798,9 +5613,45 @@ var jsonPathMatch = (base, query) => {
     query: queryExpression
   });
 };
+var json2 = {
+  key,
+  index,
+  wildcard,
+  slice,
+  descend,
+  path,
+  get: jsonGet,
+  access: jsonAccess,
+  traverse: jsonTraverse,
+  text: jsonText,
+  accessText: jsonAccessText,
+  traverseText: jsonTraverseText,
+  contains: jsonContains,
+  containedBy: jsonContainedBy,
+  hasKey: jsonHasKey,
+  keyExists: jsonKeyExists,
+  hasAnyKeys: jsonHasAnyKeys,
+  hasAllKeys: jsonHasAllKeys,
+  delete: jsonDelete,
+  remove: jsonRemove,
+  set: jsonSet,
+  insert: jsonInsert,
+  concat: jsonConcat,
+  merge: jsonMerge,
+  buildObject: jsonBuildObject,
+  buildArray: jsonBuildArray,
+  toJson: jsonToJson,
+  toJsonb: jsonToJsonb,
+  typeOf: jsonTypeOf,
+  length: jsonLength,
+  keys: jsonKeys,
+  stripNulls: jsonStripNulls,
+  pathExists: jsonPathExists,
+  pathMatch: jsonPathMatch
+};
 var jsonb = {
   key,
-  index: index3,
+  index,
   wildcard,
   slice,
   descend,
@@ -4837,7 +5688,7 @@ var and = (...values) => makeVariadicBooleanExpression("and", values.map((value)
 var or = (...values) => makeVariadicBooleanExpression("or", values.map((value) => toDialectExpression(value)));
 var not = (value) => {
   const expression = toDialectExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: expression[TypeId].nullability,
@@ -4869,7 +5720,7 @@ var overlaps = (...args) => {
 };
 var concat = (...values) => {
   const expressions = values.map((value) => toDialectStringExpression(value));
-  return makeExpression({
+  return makeExpression2({
     runtime: "",
     dbType: profile.textDb,
     nullability: mergeNullabilityManyRuntime(expressions),
@@ -4885,7 +5736,7 @@ var all_ = (...values) => and(...values);
 var any_ = (...values) => or(...values);
 var count = (value) => {
   const expression = toDialectExpression(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: 0,
     dbType: profile.numericDb,
     nullability: "never",
@@ -4898,8 +5749,8 @@ var count = (value) => {
   });
 };
 var exists = (plan) => {
-  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
-  return makeExpression({
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "never",
@@ -4912,9 +5763,9 @@ var exists = (plan) => {
   });
 };
 var scalar = (plan) => {
-  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
-  const expression = extractSingleSelectedExpressionRuntime(plan[TypeId3].selection);
-  return makeExpression({
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  const expression = extractSingleSelectedExpressionRuntime(plan[TypeId4].selection);
+  return makeExpression2({
     runtime: undefined,
     dbType: expression[TypeId].dbType,
     runtimeSchema: expression[TypeId].runtimeSchema,
@@ -4930,8 +5781,8 @@ var scalar = (plan) => {
 };
 var inSubquery = (left, plan) => {
   const leftExpression = toDialectExpression(left);
-  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
-  return makeExpression({
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "maybe",
@@ -4946,8 +5797,8 @@ var inSubquery = (left, plan) => {
 };
 var quantifiedComparison = (left, plan, operator, quantifier) => {
   const leftExpression = toDialectExpression(left);
-  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
-  return makeExpression({
+  const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId4].required).map((name) => [name, true]));
+  return makeExpression2({
     runtime: true,
     dbType: profile.boolDb,
     nullability: "maybe",
@@ -4961,7 +5812,7 @@ var compareAll = (left, plan, operator) => quantifiedComparison(left, plan, oper
 var over = (value, spec = {}) => {
   const normalized = normalizeWindowSpec(spec);
   const expressions = mergeWindowExpressions(value, normalized.partitionBy, normalized.orderBy);
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: value[TypeId].dbType,
     nullability: value[TypeId].nullability,
@@ -4979,7 +5830,7 @@ var over = (value, spec = {}) => {
 var buildNumberWindow = (kind, spec) => {
   const normalized = normalizeWindowSpec(spec);
   const expressions = mergeWindowExpressions(undefined, normalized.partitionBy, normalized.orderBy);
-  return makeExpression({
+  return makeExpression2({
     runtime: 0,
     dbType: profile.numericDb,
     nullability: "never",
@@ -4996,7 +5847,7 @@ var buildNumberWindow = (kind, spec) => {
 var rowNumber = (spec) => buildNumberWindow("rowNumber", spec);
 var rank = (spec) => buildNumberWindow("rank", spec);
 var denseRank = (spec) => buildNumberWindow("denseRank", spec);
-var max = (value) => makeExpression({
+var max = (value) => makeExpression2({
   runtime: undefined,
   dbType: value[TypeId].dbType,
   nullability: "maybe",
@@ -5007,7 +5858,7 @@ var max = (value) => makeExpression({
   kind: "max",
   value
 });
-var min = (value) => makeExpression({
+var min = (value) => makeExpression2({
   runtime: undefined,
   dbType: value[TypeId].dbType,
   nullability: "maybe",
@@ -5022,7 +5873,7 @@ var resolveCoalesceNullabilityRuntime = (values) => values.some((value) => value
 var coalesce = (...values) => {
   const expressions = values.map((value) => toDialectExpression(value));
   const representative = expressions.find((value) => value[TypeId].nullability !== "always") ?? expressions[0];
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: representative[TypeId].dbType,
     nullability: resolveCoalesceNullabilityRuntime(expressions),
@@ -5036,7 +5887,7 @@ var coalesce = (...values) => {
 };
 var call = (name, ...args) => {
   const expressions = args.map((value) => toDialectExpression(value));
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: profile.textDb,
     nullability: "maybe",
@@ -5072,7 +5923,7 @@ var finalizeCase = (branches, fallback) => {
   const resultExpressions = [...branches.map((branch) => branch.then), fallback];
   const allExpressions = [...branches.flatMap((branch) => [branch.when, branch.then]), fallback];
   const representative = resultExpressions.find((value) => value[TypeId].nullability !== "always") ?? fallback;
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: representative[TypeId].dbType,
     nullability: resolveCaseNullabilityRuntime(resultExpressions),
@@ -5140,7 +5991,7 @@ var match = (value) => {
 };
 var excluded = (value) => {
   const ast = value[TypeId2];
-  return makeExpression({
+  return makeExpression2({
     runtime: undefined,
     dbType: value[TypeId].dbType,
     runtimeSchema: value[TypeId].runtimeSchema,
@@ -5172,7 +6023,7 @@ var toMutationValueExpression = (value, column2) => {
     const ast = expression[TypeId2];
     if (ast.kind === "literal") {
       const normalizedValue2 = normalizeMutationValue(ast.value);
-      return makeExpression({
+      return makeExpression2({
         runtime: normalizedValue2,
         dbType: columnState.dbType,
         runtimeSchema: columnState.runtimeSchema,
@@ -5189,7 +6040,7 @@ var toMutationValueExpression = (value, column2) => {
     return retargetLiteralExpression(value, column2);
   }
   const normalizedValue = normalizeMutationValue(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: normalizedValue,
     dbType: columnState.dbType,
     runtimeSchema: columnState.runtimeSchema,
@@ -5210,28 +6061,28 @@ var renderQuantifiedComparisonAst = (left, plan, operator, quantifier) => ({
   plan
 });
 var targetSourceDetails = (table) => {
-  const sourceName = table[TypeId6].name;
-  const sourceBaseName = table[TypeId6].baseName;
+  const sourceName = table[TypeId7].name;
+  const sourceBaseName = table[TypeId7].baseName;
   return {
     sourceName,
     sourceBaseName
   };
 };
 var sourceDetails = (source) => {
-  if (TypeId6 in source) {
+  if (TypeId7 in source) {
     return targetSourceDetails(source);
   }
-  const record2 = source;
+  const record = source;
   return {
-    sourceName: record2.name,
-    sourceBaseName: record2.baseName
+    sourceName: record.name,
+    sourceBaseName: record.baseName
   };
 };
 var makeColumnReferenceSelection = (alias2, selection) => {
   const columns = {};
   for (const [columnName, expression] of Object.entries(selection)) {
     const state = expression[TypeId];
-    columns[columnName] = makeExpression({
+    columns[columnName] = makeExpression2({
       runtime: undefined,
       dbType: state.dbType,
       runtimeSchema: state.runtimeSchema,
@@ -5297,7 +6148,7 @@ var buildMutationAssignments = (target, values) => {
   }
   const valueMap = values;
   return targets.flatMap((table) => {
-    const targetName = table[TypeId6].name;
+    const targetName = table[TypeId7].name;
     const scopedValues = valueMap[targetName] ?? {};
     const columns = table;
     return Object.entries(scopedValues).map(([columnName, value]) => ({
@@ -5535,6 +6386,146 @@ var {
   from,
   insert
 };
+
+// src/standard/cast.ts
+var to = (...args) => args.length === 1 ? (value) => cast(value, args[0]) : cast(args[0], args[1]);
+// src/standard/function/index.ts
+var exports_function = {};
+__export(exports_function, {
+  window: () => exports_window,
+  upper: () => upper,
+  temporal: () => exports_temporal,
+  string: () => exports_string,
+  rowNumber: () => rowNumber,
+  rank: () => rank,
+  over: () => over,
+  now: () => now,
+  min: () => min,
+  max: () => max,
+  lower: () => lower,
+  localTimestamp: () => localTimestamp,
+  localTime: () => localTime,
+  denseRank: () => denseRank,
+  currentTimestamp: () => currentTimestamp,
+  currentTime: () => currentTime,
+  currentDate: () => currentDate,
+  count: () => count,
+  core: () => exports_core,
+  concat: () => concat,
+  coalesce: () => coalesce,
+  call: () => call,
+  aggregate: () => exports_aggregate
+});
+
+// src/standard/function/core.ts
+var exports_core = {};
+__export(exports_core, {
+  coalesce: () => coalesce,
+  call: () => call
+});
+
+// src/standard/query.ts
+var exports_query = {};
+__export(exports_query, {
+  withRecursive: () => withRecursive_,
+  with: () => with_,
+  where: () => where,
+  values: () => exportedValues,
+  upsert: () => upsert,
+  upper: () => upper,
+  update: () => update,
+  unnest: () => exportedUnnest,
+  union_query_capabilities: () => union_query_capabilities,
+  unionAll: () => unionAll,
+  union: () => union,
+  type: () => type,
+  truncate: () => truncate,
+  transaction: () => transaction,
+  select: () => exportedSelect,
+  scalar: () => scalar,
+  savepoint: () => savepoint,
+  rowNumber: () => rowNumber,
+  rollbackTo: () => rollbackTo,
+  rollback: () => rollback,
+  rightJoin: () => rightJoin,
+  returning: () => returning,
+  releaseSavepoint: () => releaseSavepoint,
+  regexNotMatch: () => regexNotMatch,
+  regexNotIMatch: () => regexNotIMatch,
+  regexMatch: () => regexMatch,
+  regexIMatch: () => regexIMatch,
+  rank: () => rank,
+  overlaps: () => overlaps,
+  over: () => over,
+  orderBy: () => orderBy,
+  or: () => or,
+  onConflict: () => onConflict,
+  offset: () => offset,
+  notIn: () => notIn,
+  not: () => not,
+  neq: () => neq,
+  min: () => min,
+  merge: () => merge2,
+  max: () => max,
+  match: () => match,
+  lte: () => lte,
+  lt: () => lt,
+  lower: () => lower,
+  lock: () => lock,
+  literal: () => literal,
+  limit: () => limit,
+  like: () => like,
+  leftJoin: () => leftJoin,
+  lateral: () => lateral,
+  isNull: () => isNull,
+  isNotNull: () => isNotNull,
+  isNotDistinctFrom: () => isNotDistinctFrom,
+  isDistinctFrom: () => isDistinctFrom,
+  intersectAll: () => intersectAll,
+  intersect: () => intersect,
+  insert: () => exportedInsert,
+  innerJoin: () => innerJoin,
+  inSubquery: () => inSubquery,
+  in: () => in_,
+  ilike: () => ilike,
+  having: () => having,
+  gte: () => gte,
+  gt: () => gt,
+  groupBy: () => groupBy,
+  fullJoin: () => fullJoin,
+  from: () => exportedFrom,
+  exists: () => exists,
+  excluded: () => excluded,
+  exceptAll: () => exceptAll,
+  except: () => except,
+  eq: () => eq,
+  dropTable: () => dropTable,
+  dropIndex: () => dropIndex,
+  distinct: () => distinct,
+  denseRank: () => denseRank,
+  delete: () => delete_,
+  crossJoin: () => crossJoin,
+  createTable: () => createTable,
+  createIndex: () => createIndex,
+  count: () => count,
+  contains: () => contains,
+  containedBy: () => containedBy,
+  concat: () => concat,
+  compareAny: () => compareAny,
+  compareAll: () => compareAll,
+  commit: () => commit,
+  column: () => column,
+  collate: () => collate,
+  coalesce: () => coalesce,
+  cast: () => cast,
+  case: () => case_,
+  call: () => call,
+  between: () => between,
+  as: () => as,
+  any: () => any_,
+  and: () => and,
+  all: () => all_
+});
 // src/standard/function/string.ts
 var exports_string = {};
 __export(exports_string, {
@@ -5567,7 +6558,7 @@ __export(exports_temporal, {
   currentTime: () => currentTime,
   currentDate: () => currentDate
 });
-var makeTemporal = (name, dbType, runtimeSchema) => makeExpression({
+var makeTemporal = (name, dbType, runtimeSchema) => makeExpression2({
   runtime: undefined,
   dbType,
   runtimeSchema,
@@ -5586,11 +6577,240 @@ var currentTime = () => makeTemporal("current_time", standardDatatypes.time(), L
 var currentTimestamp = () => makeTemporal("current_timestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema);
 var localTime = () => makeTemporal("localtime", standardDatatypes.time(), LocalTimeStringSchema);
 var localTimestamp = () => makeTemporal("localtimestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema);
+// src/standard/json.ts
+var exports_json = {};
+__export(exports_json, {
+  wildcard: () => wildcard2,
+  typeOf: () => typeOf,
+  traverseText: () => traverseText,
+  traverse: () => traverse,
+  toJsonb: () => toJsonb,
+  toJson: () => toJson,
+  text: () => text2,
+  slice: () => slice2,
+  set: () => set,
+  remove: () => remove,
+  pathExists: () => pathExists,
+  merge: () => merge3,
+  length: () => length,
+  keys: () => keys,
+  keyExists: () => keyExists,
+  key: () => key2,
+  insert: () => insert2,
+  index: () => index4,
+  hasKey: () => hasKey,
+  hasAnyKeys: () => hasAnyKeys,
+  hasAllKeys: () => hasAllKeys,
+  get: () => get,
+  descend: () => descend2,
+  delete_: () => delete_2,
+  delete: () => delete_2,
+  contains: () => contains2,
+  containedBy: () => containedBy2,
+  concat: () => concat2,
+  buildObject: () => buildObject,
+  buildArray: () => buildArray,
+  accessText: () => accessText,
+  access: () => access
+});
+var emptyPath = path();
+var isObjectLike2 = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isExpression4 = (value) => isObjectLike2(value) && (TypeId in value);
+var isPath = (value) => isObjectLike2(value) && (TypeId3 in value);
+var isSegment = (value) => isObjectLike2(value) && (SegmentTypeId in value);
+var isTarget = (value) => isPath(value) || isSegment(value);
+var normalizeSegment2 = (segment) => {
+  switch (segment.kind) {
+    case "key":
+      return key(segment.key);
+    case "index":
+      return index(segment.index);
+    case "wildcard":
+      return wildcard();
+    case "slice":
+      return slice(segment.start, segment.end);
+    case "descend":
+      return descend();
+  }
+};
+var normalizeTarget = (target) => isPath(target) ? path(...target.segments.map(normalizeSegment2)) : normalizeSegment2(target);
+var normalizeTargetPath = (target) => isPath(target) ? path(...target.segments.map(normalizeSegment2)) : path(normalizeSegment2(target));
+var accessKinds2 = new Set([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+]);
+var accessPathOf2 = (value) => {
+  const segments = [];
+  let base = value;
+  while (isExpression4(base)) {
+    const ast = base[TypeId2];
+    if (typeof ast.kind !== "string" || !accessKinds2.has(ast.kind) || !isExpression4(ast.base) || !Array.isArray(ast.segments)) {
+      break;
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment2));
+    base = ast.base;
+  }
+  return segments.length === 0 ? undefined : {
+    base,
+    path: path(...segments)
+  };
+};
+var targetOrAccessPath = (value) => isExpression4(value) ? accessPathOf2(value) : undefined;
+var segmentOperation = (segment) => Object.assign((base) => json2.get(base, segment), segment);
+var key2 = (value) => segmentOperation(key(value));
+var index4 = (value) => segmentOperation(index(value));
+var wildcard2 = () => segmentOperation(wildcard());
+var slice2 = (start, end) => segmentOperation(slice(start, end));
+var descend2 = () => segmentOperation(descend());
+var get = (...args) => {
+  if (args.length === 1) {
+    const [first] = args;
+    if (isTarget(first)) {
+      return (base2) => json2.get(base2, normalizeTarget(first));
+    }
+    const access = targetOrAccessPath(first);
+    return access === undefined ? first : json2.get(access.base, access.path);
+  }
+  const [base, target] = args;
+  return json2.get(base, normalizeTarget(target));
+};
+var text2 = (...args) => {
+  if (args.length === 1) {
+    const [first] = args;
+    if (isTarget(first)) {
+      return (base2) => json2.text(base2, normalizeTarget(first));
+    }
+    const access = targetOrAccessPath(first);
+    return access === undefined ? json2.text(first, emptyPath) : json2.text(access.base, access.path);
+  }
+  const [base, target] = args;
+  return json2.text(base, normalizeTarget(target));
+};
+var delete_2 = (...args) => {
+  if (args.length === 1) {
+    const [first] = args;
+    if (isTarget(first)) {
+      return (base2) => json2.delete(base2, normalizeTarget(first));
+    }
+    const access = targetOrAccessPath(first);
+    if (access === undefined) {
+      throw new Error("Json.delete requires a piped JSON path or an explicit target");
+    }
+    return json2.delete(access.base, access.path);
+  }
+  const [base, target] = args;
+  return json2.delete(base, normalizeTarget(target));
+};
+var access = json2.access;
+var traverse = json2.traverse;
+var accessText = json2.accessText;
+var traverseText = json2.traverseText;
+var contains2 = json2.contains;
+var containedBy2 = json2.containedBy;
+var hasKey = (...args) => {
+  if (args.length === 1) {
+    const [key4] = args;
+    return (base2) => json2.hasKey(base2, key4);
+  }
+  const [base, key3] = args;
+  return json2.hasKey(base, key3);
+};
+var keyExists = hasKey;
+var hasAnyKeys = (base, ...keys) => json2.hasAnyKeys(base, ...keys);
+var hasAllKeys = (base, ...keys) => json2.hasAllKeys(base, ...keys);
+var remove = (...args) => {
+  if (args.length === 1) {
+    const [first] = args;
+    if (isTarget(first)) {
+      return (base2) => json2.remove(base2, normalizeTarget(first));
+    }
+    const access2 = targetOrAccessPath(first);
+    if (access2 === undefined) {
+      throw new Error("Json.remove requires a piped JSON path or an explicit target");
+    }
+    return json2.remove(access2.base, access2.path);
+  }
+  const [base, target] = args;
+  return json2.remove(base, normalizeTarget(target));
+};
+var set = (...args) => {
+  if (args.length === 1 || args.length === 2 && !isExpression4(args[0])) {
+    const [next2, options3] = args;
+    return (base2) => {
+      const access2 = accessPathOf2(base2);
+      if (access2 === undefined) {
+        throw new Error("Json.set requires a piped JSON path or an explicit target");
+      }
+      return json2.set(access2.base, access2.path, next2, options3);
+    };
+  }
+  if ((args.length === 2 || args.length === 3) && isExpression4(args[0]) && !isTarget(args[1])) {
+    const [base2, next2, options3] = args;
+    const access2 = accessPathOf2(base2);
+    if (access2 === undefined) {
+      throw new Error("Json.set requires a piped JSON path or an explicit target");
+    }
+    return json2.set(access2.base, access2.path, next2, options3);
+  }
+  const [base, target, next, options2] = args;
+  return json2.set(base, normalizeTarget(target), next, options2);
+};
+var insert2 = (...args) => {
+  if (args.length === 1 || args.length === 2 && !isExpression4(args[0])) {
+    const [next2, options3] = args;
+    return (base2) => {
+      const access2 = accessPathOf2(base2);
+      if (access2 === undefined) {
+        throw new Error("Json.insert requires a piped JSON path or an explicit target");
+      }
+      return json2.insert(access2.base, access2.path, next2, options3);
+    };
+  }
+  if ((args.length === 2 || args.length === 3) && isExpression4(args[0]) && !isTarget(args[1])) {
+    const [base2, next2, options3] = args;
+    const access2 = accessPathOf2(base2);
+    if (access2 === undefined) {
+      throw new Error("Json.insert requires a piped JSON path or an explicit target");
+    }
+    return json2.insert(access2.base, access2.path, next2, options3);
+  }
+  const [base, target, next, options2] = args;
+  return json2.insert(base, normalizeTarget(target), next, options2);
+};
+var concat2 = json2.concat;
+var merge3 = json2.merge;
+var buildObject = json2.buildObject;
+var buildArray = json2.buildArray;
+var toJson = json2.toJson;
+var toJsonb = json2.toJsonb;
+var typeOf = json2.typeOf;
+var length = json2.length;
+var keys = json2.keys;
+var pathExists = (...args) => {
+  if (args.length === 1) {
+    const [first] = args;
+    if (isTarget(first) || typeof first === "string") {
+      return (base2) => json2.pathExists(base2, isTarget(first) ? normalizeTargetPath(first) : first);
+    }
+    const access2 = targetOrAccessPath(first);
+    if (access2 === undefined) {
+      throw new Error("Json.pathExists requires a piped JSON path or an explicit query");
+    }
+    return json2.pathExists(access2.base, access2.path);
+  }
+  const [base, query] = args;
+  return json2.pathExists(base, isTarget(query) ? normalizeTargetPath(query) : query);
+};
 // src/internal/executor.ts
 var exports_executor = {};
 __export(exports_executor, {
   withTransaction: () => withTransaction,
-  withSavepoint: () => withSavepoint,
   streamFromSqlClient: () => streamFromSqlClient,
   remapRows: () => remapRows,
   makeRowDecoder: () => makeRowDecoder,
@@ -5604,9 +6824,10 @@ __export(exports_executor, {
 });
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
 import * as Schema9 from "effect/Schema";
-import * as SqlClient from "@effect/sql/SqlClient";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
 // src/internal/runtime/driver-value-mapping.ts
@@ -5653,9 +6874,9 @@ var mappingCandidates = (context) => {
     runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
   ];
 };
-var findMapping = (context, key2) => {
+var findMapping = (context, key3) => {
   for (const candidate of mappingCandidates(context)) {
-    const value = candidate?.[key2];
+    const value = candidate?.[key3];
     if (value !== undefined) {
       return value;
     }
@@ -5783,7 +7004,7 @@ var renderJsonSelectSql = (sql, context) => {
 import * as Schema8 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema8.Number.pipe(Schema8.finite());
+var FiniteNumberSchema = Schema8.Number.check(Schema8.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
@@ -5811,14 +7032,11 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema8.Uint8ArrayFromSelf;
+      return Schema8.Uint8Array;
     case "array":
       return Schema8.Array(Schema8.Unknown);
     case "record":
-      return Schema8.Record({
-        key: Schema8.String,
-        value: Schema8.Unknown
-      });
+      return Schema8.Record(Schema8.String, Schema8.Unknown);
     case "null":
       return Schema8.Null;
     case "unknown":
@@ -5836,7 +7054,7 @@ var runtimeSchemaForDbType = (dbType) => {
     return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
   }
   if ("fields" in dbType) {
-    const fields = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
+    const fields = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
     return Schema8.Struct(fields);
   }
   if ("variant" in dbType && dbType.variant === "json") {
@@ -5856,27 +7074,23 @@ var unionAst = (asts) => {
   if (asts.length === 1) {
     return asts[0];
   }
-  return SchemaAST.Union.make(asts);
+  return new SchemaAST.Union(asts, "anyOf");
 };
-var propertyAstOf = (ast, key2) => {
+var propertyAstOf = (ast, key3) => {
   switch (ast._tag) {
-    case "Transformation":
-      return propertyAstOf(SchemaAST.typeAST(ast), key2);
-    case "Refinement":
-      return propertyAstOf(ast.from, key2);
     case "Suspend":
-      return propertyAstOf(ast.f(), key2);
-    case "TypeLiteral": {
-      const property = ast.propertySignatures.find((entry) => entry.name === key2);
+      return propertyAstOf(ast.thunk(), key3);
+    case "Objects": {
+      const property = ast.propertySignatures.find((entry) => entry.name === key3);
       if (property !== undefined) {
         return property.type;
       }
-      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
-      return index4?.type;
+      const index5 = ast.indexSignatures.find((entry) => entry.parameter._tag === "String");
+      return index5?.type;
     }
     case "Union": {
       const values2 = ast.types.flatMap((member) => {
-        const next = propertyAstOf(member, key2);
+        const next = propertyAstOf(member, key3);
         return next === undefined ? [] : [next];
       });
       return unionAst(values2);
@@ -5885,27 +7099,23 @@ var propertyAstOf = (ast, key2) => {
       return;
   }
 };
-var numberAstOf = (ast, index4) => {
+var numberAstOf = (ast, index5) => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index4);
-    case "Refinement":
-      return numberAstOf(ast.from, index4);
     case "Suspend":
-      return numberAstOf(ast.f(), index4);
-    case "TupleType": {
-      const element = ast.elements[index4];
+      return numberAstOf(ast.thunk(), index5);
+    case "Arrays": {
+      const element = ast.elements[index5];
       if (element !== undefined) {
-        return element.type;
+        return element;
       }
       if (ast.rest.length === 0) {
         return;
       }
-      return unionAst(ast.rest.map((entry) => entry.type));
+      return unionAst(ast.rest);
     }
     case "Union": {
       const values2 = ast.types.flatMap((member) => {
-        const next = numberAstOf(member, index4);
+        const next = numberAstOf(member, index5);
         return next === undefined ? [] : [next];
       });
       return unionAst(values2);
@@ -5916,7 +7126,7 @@ var numberAstOf = (ast, index4) => {
 };
 var exactJsonSegments = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index");
 var schemaAstAtExactJsonPath = (schema3, segments) => {
-  let current = SchemaAST.typeAST(schema3.ast);
+  let current = schema3.ast;
   for (const segment of segments) {
     if (segment.kind === "key") {
       const property = propertyAstOf(current, segment.key);
@@ -5946,28 +7156,28 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema8.Union(...resolved);
+  return Schema8.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
   return flattenSelection(selection)[0]?.expression;
 };
 var isJsonCompatibleAst = (ast) => {
+  ast = SchemaAST.toType(ast);
   switch (ast._tag) {
-    case "StringKeyword":
-    case "NumberKeyword":
-    case "BooleanKeyword":
-    case "TupleType":
-    case "TypeLiteral":
+    case "String":
+    case "Number":
+    case "Boolean":
+    case "Null":
+    case "Arrays":
+    case "Objects":
       return true;
     case "Literal":
-      return ast.literal === null || typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
+      return typeof ast.literal === "string" || typeof ast.literal === "number" || typeof ast.literal === "boolean";
     case "Union":
       return ast.types.every(isJsonCompatibleAst);
-    case "Transformation":
-      return isJsonCompatibleAst(SchemaAST.typeAST(ast));
     case "Suspend":
-      return isJsonCompatibleAst(ast.f());
+      return isJsonCompatibleAst(ast.thunk());
     default:
       return false;
   }
@@ -5976,14 +7186,14 @@ var jsonCompatibleSchema = (schema3) => {
   if (schema3 === undefined) {
     return;
   }
-  const ast = SchemaAST.typeAST(schema3.ast);
+  const ast = SchemaAST.toType(schema3.ast);
   return isJsonCompatibleAst(ast) ? schema3 : JsonValueSchema;
 };
 var buildStructSchema = (entries, context) => {
   const fields = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
   return Schema8.Struct(fields);
 };
-var buildTupleSchema = (values2, context) => Schema8.Tuple(...values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema8.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -6138,15 +7348,15 @@ var expressionRuntimeSchema = (expression, context) => {
 // src/internal/executor.ts
 var setPath2 = (target, path2, value) => {
   let current = target;
-  for (let index4 = 0;index4 < path2.length - 1; index4++) {
-    const key2 = path2[index4];
-    const existing = current[key2];
+  for (let index5 = 0;index5 < path2.length - 1; index5++) {
+    const key3 = path2[index5];
+    const existing = current[key3];
     if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
       current = existing;
       continue;
     }
     const next = {};
-    current[key2] = next;
+    current[key3] = next;
     current = next;
   }
   current[path2[path2.length - 1]] = value;
@@ -6189,24 +7399,31 @@ var remapRows = (query, rows) => rows.map((row) => {
   }
   return decoded;
 });
-var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => ({
-  _tag: "RowDecodeError",
-  message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
-  dialect: rendered.dialect,
-  query: {
-    sql: rendered.sql,
-    params: rendered.params
-  },
-  projection: {
-    alias: projection.alias,
-    path: projection.path
-  },
-  dbType: expression[TypeId].dbType,
-  raw,
-  normalized,
-  stage,
-  cause
-});
+var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
+  const schemaError = Schema9.isSchemaError(cause) ? {
+    message: cause.message,
+    issue: cause.issue
+  } : undefined;
+  return {
+    _tag: "RowDecodeError",
+    message: stage === "normalize" ? `Failed to normalize projection '${projection.alias}'` : `Failed to decode projection '${projection.alias}' against its runtime schema`,
+    dialect: rendered.dialect,
+    query: {
+      sql: rendered.sql,
+      params: rendered.params
+    },
+    projection: {
+      alias: projection.alias,
+      path: projection.path
+    },
+    dbType: expression[TypeId].dbType,
+    raw,
+    normalized,
+    stage,
+    cause,
+    ...schemaError === undefined ? {} : { schemaError }
+  };
+};
 var hasOptionalSourceDependency = (expression, scope) => {
   const state = expression[TypeId];
   return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
@@ -6218,11 +7435,11 @@ var effectiveRuntimeNullability = (expression, scope) => {
     return "always";
   }
   if (ast.kind === "column") {
-    const key2 = columnPredicateKey(ast.tableName, ast.columnName);
-    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key2)) {
+    const key3 = columnPredicateKey(ast.tableName, ast.columnName);
+    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key3)) {
       return "always";
     }
-    if (scope.nonNullKeys.has(key2)) {
+    if (scope.nonNullKeys.has(key3)) {
       return "never";
     }
   }
@@ -6249,8 +7466,8 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
         driverValueMapping: expression[TypeId].driverValueMapping,
         valueMappings
       });
-    } catch (cause) {
-      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
+    } catch (cause2) {
+      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause2);
     }
   }
   const nullability = effectiveRuntimeNullability(expression, scope);
@@ -6276,18 +7493,22 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (Schema9.is(schema3)(normalized)) {
     return normalized;
   }
-  try {
-    return Schema9.decodeUnknownSync(schema3)(normalized);
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  const decoded = Schema9.decodeUnknownExit(schema3)(normalized);
+  if (Exit.isSuccess(decoded)) {
+    return decoded.value;
   }
+  const cause = Option.match(Exit.findErrorOption(decoded), {
+    onNone: () => decoded.cause,
+    onSome: (schemaError) => schemaError
+  });
+  throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
 };
 var makeRowDecoder = (rendered, plan, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
   const byPath = new Map(projections.map((projection) => [JSON.stringify(projection.path), projection.expression]));
   const driverMode = options2.driverMode ?? "raw";
   const valueMappings = options2.valueMappings ?? rendered.valueMappings;
-  const scope = resolveImplicationScope(plan[TypeId3].available, getQueryState(plan).assumptions);
+  const scope = resolveImplicationScope(plan[TypeId4].available, getQueryState(plan).assumptions);
   return (row) => {
     const decoded = {};
     for (const projection of rendered.projections) {
@@ -6305,7 +7526,7 @@ var makeRowDecoder = (rendered, plan, options2 = {}) => {
 };
 var decodeChunk = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
-  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)));
+  return Chunk.fromIterable(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)));
 };
 var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
@@ -6343,12 +7564,12 @@ var fromDriver = (renderer, sqlDriver) => {
     },
     stream(plan) {
       const rendered = renderer.render(plan);
-      return Stream.mapChunks(sqlDriver.stream(rendered), (rows) => Chunk.unsafeFromArray(remapRows(rendered, Chunk.toReadonlyArray(rows))));
+      return Stream.mapArray(sqlDriver.stream(rendered), (rows) => remapRows(rendered, rows));
     }
   };
   return executor;
 };
-var streamFromSqlClient = (query) => Stream.unwrapScoped(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(SqlClient.TransactionConnection), Option.match({
+var streamFromSqlClient = (query) => Stream.unwrap(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(sql.transactionService), Option.match({
   onNone: () => sql.reserve,
   onSome: ([connection]) => Effect.succeed(connection)
 })).pipe(Effect.map((connection) => connection.executeStream(query.sql, [...query.params], undefined)))));
@@ -6357,7 +7578,6 @@ var fromSqlClient = (renderer) => fromDriver(renderer, driver(renderer.dialect,
   stream: (query) => streamFromSqlClient(query)
 }));
 var withTransaction = (effect) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(effect));
-var withSavepoint = (effect) => Effect.flatMap(SqlClient.SqlClient, (sql) => sql.withTransaction(effect));
 // src/standard/table.ts
 var exports_table2 = {};
 __export(exports_table2, {
@@ -6369,15 +7589,15 @@ __export(exports_table2, {
   option: () => option2,
   make: () => make4,
   insertSchema: () => insertSchema3,
-  index: () => index4,
+  index: () => index5,
   foreignKey: () => foreignKey3,
-  check: () => check2,
+  check: () => check3,
   alias: () => alias2,
   TypeId: () => TypeId10,
   OptionsSymbol: () => OptionsSymbol2,
   Class: () => Class2
 });
-var TypeId10 = TypeId6;
+var TypeId10 = TypeId7;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
 var option2 = option;
@@ -6391,17 +7611,83 @@ var Class2 = (name, schemaName = undefined) => {
 };
 var primaryKey4 = primaryKey3;
 var unique4 = unique3;
-var index4 = index2;
-var foreignKey3 = (columns, target, referencedColumns) => foreignKey2(columns, target, referencedColumns);
-var check2 = check;
+var index5 = index3;
+var foreignKey3 = foreignKey2;
+var check3 = check2;
 var selectSchema3 = selectSchema2;
 var insertSchema3 = insertSchema2;
 var updateSchema3 = updateSchema2;
+// src/standard/primary-key.ts
+var exports_primary_key = {};
+__export(exports_primary_key, {
+  named: () => named,
+  make: () => make5
+});
+var make5 = primaryKey3;
+var named = (name) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  name
+}));
+// src/standard/unique.ts
+var exports_unique = {};
+__export(exports_unique, {
+  named: () => named2,
+  make: () => make6
+});
+var make6 = unique3;
+var named2 = (name) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  name
+}));
+// src/standard/index.ts
+var exports_standard = {};
+__export(exports_standard, {
+  named: () => named3,
+  make: () => make7
+});
+var make7 = index3;
+var named3 = (name) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  name
+}));
+// src/standard/foreign-key.ts
+var exports_foreign_key = {};
+__export(exports_foreign_key, {
+  onUpdate: () => onUpdate,
+  onDelete: () => onDelete,
+  named: () => named4,
+  make: () => make8
+});
+var make8 = foreignKey2;
+var named4 = (name) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  name
+}));
+var onDelete = (action) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  onDelete: action
+}));
+var onUpdate = (action) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  onUpdate: action
+}));
+// src/standard/check.ts
+var exports_check = {};
+__export(exports_check, {
+  named: () => named5,
+  make: () => make9
+});
+var make9 = check2;
+var named5 = (name) => (option3) => mapOption(option3, (spec) => ({
+  ...spec,
+  name
+}));
 // src/standard/renderer.ts
 var exports_renderer = {};
 __export(exports_renderer, {
-  make: () => make5
+  make: () => make10
 });
+import { pipeArguments as pipeArguments8 } from "effect/Pipeable";
 
 // src/internal/renderer.ts
 var TypeId11 = Symbol.for("effect-qb/Renderer");
@@ -6473,14 +7759,15 @@ var renderDbTypeName = (value) => value;
 // src/internal/dialect-renderers/postgres.ts
 import * as Schema10 from "effect/Schema";
 var renderDbType = (dialect, dbType) => {
-  if (dialect.name === "postgres" && dbType.kind === "blob") {
-    return "bytea";
-  }
-  return renderDbTypeName(dbType.kind);
+  return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind);
 };
 var isArrayDbType = (dbType) => ("element" in dbType);
 var renderCastType = (dialect, dbType) => {
   const kind = dbType?.kind;
+  const portableType = renderPortableDatatypeCastType(dialect.name, kind);
+  if (portableType !== undefined) {
+    return renderDbTypeName(portableType);
+  }
   if (dialect.name !== "mysql") {
     return renderDbTypeName(kind);
   }
@@ -6502,13 +7789,13 @@ var renderCastType = (dialect, dbType) => {
       return renderDbTypeName(kind);
   }
 };
-var casingForTable = (table, state) => merge(state.casing, table[TypeId6].casing);
+var casingForTable = (table, state) => merge(state.casing, table[TypeId7].casing);
 var casedTableName = (table, state) => {
-  const tableState = table[TypeId6];
+  const tableState = table[TypeId7];
   return applyCategory(casingForTable(table, state), "tables", tableState.baseName);
 };
 var casedSchemaName = (table, state) => {
-  const schemaName = table[TypeId6].schemaName;
+  const schemaName = table[TypeId7].schemaName;
   return schemaName === undefined ? undefined : applyCategory(casingForTable(table, state), "schemas", schemaName);
 };
 var casedColumnName = (columnName, state, tableName) => {
@@ -6522,7 +7809,7 @@ var casedColumnName = (columnName, state, tableName) => {
 };
 var casedTableReferenceName = (tableName, state) => state.sourceNames?.get(tableName)?.tableName ?? applyCategory(state.casing, "tables", tableName);
 var quoteColumn = (columnName, state, dialect, tableName) => dialect.quoteIdentifier(casedColumnName(columnName, state, tableName));
-var stateWithTableCasing = (state, source) => typeof source === "object" && source !== null && (TypeId6 in source) ? { ...state, casing: casingForTable(source, state) } : state;
+var stateWithTableCasing = (state, source) => typeof source === "object" && source !== null && (TypeId7 in source) ? { ...state, casing: casingForTable(source, state) } : state;
 var referenceCasing = (reference, state) => merge(state.casing, reference.casing);
 var renderReferenceTable = (reference, state, dialect) => {
   const casing = referenceCasing(reference, state);
@@ -6535,9 +7822,9 @@ var registerSourceReference = (source, tableName, state) => {
   if (typeof source !== "object" || source === null) {
     return;
   }
-  if (TypeId6 in source) {
+  if (TypeId7 in source) {
     const table = source;
-    const tableState = table[TypeId6];
+    const tableState = table[TypeId7];
     const casing = casingForTable(table, state);
     const renderedTableName = tableState.kind === "alias" ? tableName : applyCategory(casing, "tables", tableState.baseName);
     const columns = new Map(Object.keys(tableState.fields).map((columnName) => [
@@ -6651,11 +7938,11 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
   }
   const table = targetSource.source;
   const tableCasing = casingForTable(table, state);
-  const fields = table[TypeId6].fields;
+  const fields = table[TypeId7].fields;
   const definitions = Object.entries(fields).map(([columnName, column2]) => renderColumnDefinition(dialect, state, columnName, column2, targetSource.tableName, tableCasing));
   const options3 = table[OptionsSymbol];
   const tableOptions = Array.isArray(options3) ? options3 : [options3];
-  validateOptions(table[TypeId6].name, fields, tableOptions);
+  validateOptions(table[TypeId7].name, fields, tableOptions);
   for (const option3 of tableOptions) {
     if (typeof option3 !== "object" || option3 === null || !("kind" in option3)) {
       continue;
@@ -6714,8 +8001,8 @@ var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
     throw new Error(`Unsupported ${dialect.name} drop index options`);
   }
   if (dialect.name === "postgres") {
-    const table2 = typeof targetSource.source === "object" && targetSource.source !== null && TypeId6 in targetSource.source ? targetSource.source : undefined;
-    const schemaName = table2?.[TypeId6].schemaName;
+    const table2 = typeof targetSource.source === "object" && targetSource.source !== null && TypeId7 in targetSource.source ? targetSource.source : undefined;
+    const schemaName = table2?.[TypeId7].schemaName;
     const tableCasing2 = table2 === undefined ? state.casing : casingForTable(table2, state);
     const renderedSchemaName = table2 === undefined ? schemaName : casedSchemaName(table2, state);
     const renderedIndexName = applyCategory(tableCasing2, "indexes", name);
@@ -6726,7 +8013,7 @@ var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
   const tableCasing = casingForTable(table, state);
   return `drop index ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
 };
-var isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var isExpression5 = (value) => value !== null && typeof value === "object" && (TypeId in value);
 var isJsonDbType2 = (dbType) => {
   if (dbType.kind === "jsonb" || dbType.kind === "json") {
     return true;
@@ -6737,7 +8024,7 @@ var isJsonDbType2 = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType2(value[TypeId].dbType);
+var isJsonExpression2 = (value) => isExpression5(value) && isJsonDbType2(value[TypeId].dbType);
 var expectValueExpression = (_functionName, value) => value;
 var expectBinaryExpressions = (_functionName, left, right) => [left, right];
 var renderBinaryExpression = (functionName, operator, left, right, state, dialect) => {
@@ -6784,7 +8071,7 @@ var unsupportedJsonFeature = (dialect, feature) => {
   throw error;
 };
 var extractJsonBase = (node) => node.value ?? node.base ?? node.input ?? node.left ?? node.target;
-var isJsonPathValue2 = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isJsonPathValue2 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var isOptionalJsonPathNumber = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
 var isJsonPathSegment = (segment) => {
   if (typeof segment === "string") {
@@ -6800,8 +8087,8 @@ var isJsonPathSegment = (segment) => {
     case "key":
       return typeof segment.key === "string";
     case "index": {
-      const index5 = segment.index;
-      return typeof index5 === "number" && Number.isFinite(index5);
+      const index6 = segment.index;
+      return typeof index6 === "number" && Number.isFinite(index6);
     }
     case "wildcard":
     case "descend":
@@ -6841,7 +8128,7 @@ var extractJsonPathSegments = (node) => {
       return [key(segment)];
     }
     if (typeof segment === "number") {
-      return [index3(segment)];
+      return [index(segment)];
     }
     if (segment !== null && typeof segment === "object" && SegmentTypeId in segment) {
       return [segment];
@@ -6914,7 +8201,7 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression3(value)) {
+  if (!isExpression5(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression2(value, state, dialect);
@@ -6958,7 +8245,7 @@ var renderJsonOpaquePath = (value, state, dialect) => {
     }
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression3(value)) {
+  if (isExpression5(value)) {
     const ast = value[TypeId2];
     if (ast.kind === "literal" && typeof ast.value === "string" && ast.value.trim().length === 0) {
       throw new Error("SQL/JSON path input must be a non-empty string");
@@ -7008,8 +8295,8 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
   const base = extractJsonBase(ast);
   const segments = extractJsonPathSegments(ast);
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index");
-  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression(expression) ? renderPostgresJsonKind(expression) : undefined;
-  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression(base) ? renderPostgresJsonKind(base) : undefined;
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression2(expression) ? renderPostgresJsonKind(expression) : undefined;
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression2(base) ? renderPostgresJsonKind(base) : undefined;
   switch (kind) {
     case "jsonGet":
     case "jsonPath":
@@ -7019,7 +8306,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       const baseSql = renderExpression2(base, state, dialect);
@@ -7042,24 +8329,24 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression2(base, state, dialect);
-      const keys = extractJsonKeys(ast, segments);
-      if (keys.length === 0) {
+      const keys2 = extractJsonKeys(ast, segments);
+      if (keys2.length === 0) {
         return;
       }
-      if (keys.some((key2) => typeof key2 !== "string" || key2.length === 0)) {
+      if (keys2.some((key3) => typeof key3 !== "string" || key3.length === 0)) {
         throw new Error("json key predicates require string keys");
       }
-      const keyNames = keys;
+      const keyNames = keys2;
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?| array[${keyNames.map((key3) => renderPostgresTextLiteral(key3, state, dialect)).join(", ")}])`;
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?& array[${keyNames.map((key3) => renderPostgresTextLiteral(key3, state, dialect)).join(", ")}])`;
         }
         return `(${baseSql} ? ${renderPostgresTextLiteral(keyNames[0], state, dialect)})`;
       }
@@ -7072,7 +8359,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
+      if (!isExpression5(ast.left) || !isExpression5(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7109,7 +8396,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7120,7 +8407,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7131,7 +8418,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7143,36 +8430,36 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         const baseSql = renderExpression2(base, state, dialect);
-        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
+        const typeOf2 = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
         const arrayLength = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_array_length`;
         const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`;
-        return `(case when ${typeOf}(${baseSql}) = 'array' then ${arrayLength}(${baseSql}) when ${typeOf}(${baseSql}) = 'object' then (select count(*)::int from ${objectKeys}(${baseSql})) else null end)`;
+        return `(case when ${typeOf2}(${baseSql}) = 'array' then ${arrayLength}(${baseSql}) when ${typeOf2}(${baseSql}) = 'object' then (select count(*)::int from ${objectKeys}(${baseSql})) else null end)`;
       }
       if (dialect.name === "mysql") {
         return `json_length(${renderExpression2(base, state, dialect)})`;
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         const baseSql = renderExpression2(base, state, dialect);
-        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
+        const typeOf2 = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
         const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`;
-        return `(case when ${typeOf}(${baseSql}) = 'object' then to_json(array(select ${objectKeys}(${baseSql}))) else null end)`;
+        return `(case when ${typeOf2}(${baseSql}) = 'object' then to_json(array(select ${objectKeys}(${baseSql}))) else null end)`;
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression2(base, state, dialect)})`;
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7183,7 +8470,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7201,11 +8488,11 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue(ast);
-      if (!isExpression3(nextValue)) {
+      if (!isExpression5(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -7222,7 +8509,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -7238,7 +8525,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression3(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -7335,9 +8622,9 @@ var validateDistinctOnOrdering = (distinctOn2, orderBy2) => {
   }
   const remainingDistinctKeys = new Set(distinctOn2.map(groupingKeyOfExpression));
   for (const order of orderBy2) {
-    const key2 = groupingKeyOfExpression(order.value);
-    if (remainingDistinctKeys.has(key2)) {
-      remainingDistinctKeys.delete(key2);
+    const key3 = groupingKeyOfExpression(order.value);
+    if (remainingDistinctKeys.has(key3)) {
+      remainingDistinctKeys.delete(key3);
       continue;
     }
     if (remainingDistinctKeys.size > 0) {
@@ -7432,12 +8719,12 @@ var renderQueryAst2 = (ast, state, dialect, options3 = {}) => {
         const columns = insertSource.columns.map((column2) => quoteColumn(column2, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
-          const fields = table[TypeId6].fields;
+          const fields = table[TypeId7].fields;
           const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = insertSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index5) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index5], state, targetSource.source[TypeId6].fields[entry.columnName][TypeId])).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index6) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index6], state, targetSource.source[TypeId7].fields[entry.columnName][TypeId])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -7591,27 +8878,27 @@ var renderQueryAst2 = (ast, state, dialect, options3 = {}) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge3 = mergeAst.merge;
-      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge3.on, state, dialect)}`;
-      if (merge3.whenMatched) {
-        const matchedKind = merge3.whenMatched.kind === "delete" ? "delete" : "update";
+      const merge4 = mergeAst.merge;
+      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge4.on, state, dialect)}`;
+      if (merge4.whenMatched) {
+        const matchedKind = merge4.whenMatched.kind === "delete" ? "delete" : "update";
         sql += " when matched";
-        if (merge3.whenMatched.predicate) {
-          sql += ` and ${renderExpression2(merge3.whenMatched.predicate, state, dialect)}`;
+        if (merge4.whenMatched.predicate) {
+          sql += ` and ${renderExpression2(merge4.whenMatched.predicate, state, dialect)}`;
         }
         if (matchedKind === "delete") {
           sql += " then delete";
         } else {
-          const matchedUpdate = merge3.whenMatched;
+          const matchedUpdate = merge4.whenMatched;
           sql += ` then update set ${matchedUpdate.values.map((entry) => `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge3.whenNotMatched) {
+      if (merge4.whenNotMatched) {
         sql += " when not matched";
-        if (merge3.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression2(merge3.whenNotMatched.predicate, state, dialect)}`;
+        if (merge4.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression2(merge4.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge3.whenNotMatched.values.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge3.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge4.whenNotMatched.values.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge4.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -7675,7 +8962,7 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   };
   const renderUnnestRows = (arrays, columnNames) => {
     const rowCount = arrays[columnNames[0]].length;
-    const rows = Array.from({ length: rowCount }, (_, index5) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index5]])));
+    const rows = Array.from({ length: rowCount }, (_, index6) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index6]])));
     return renderSelectRows(rows, columnNames);
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
@@ -7725,11 +9012,11 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     const columnNames = Object.keys(tableFunction.columns);
     return `${functionName}(${tableFunction.args.map((arg) => renderExpression2(arg, state, dialect)).join(", ")}) as ${dialect.quoteIdentifier(tableFunction.name)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`;
   }
-  const schemaName = typeof source === "object" && source !== null && TypeId6 in source ? casedSchemaName(source, state) : undefined;
-  if (typeof source === "object" && source !== null && TypeId6 in source) {
+  const schemaName = typeof source === "object" && source !== null && TypeId7 in source ? casedSchemaName(source, state) : undefined;
+  if (typeof source === "object" && source !== null && TypeId7 in source) {
     const table = source;
     const renderedBaseName = casedTableName(table, state);
-    const renderedTableName = table[TypeId6].kind === "alias" ? tableName : renderedBaseName;
+    const renderedTableName = table[TypeId7].kind === "alias" ? tableName : renderedBaseName;
     return dialect.renderTableReference(renderedTableName, renderedBaseName, schemaName);
   }
   return dialect.renderTableReference(applyCategory(state.casing, "tables", tableName), applyCategory(state.casing, "tables", baseTableName), schemaName);
@@ -7836,11 +9123,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("contains", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} @> ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_contains(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -7849,11 +9136,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("containedBy", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} <@ ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_contains(${renderExpression2(rightExpression, state, dialect)}, ${renderExpression2(leftExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -7862,11 +9149,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("overlaps", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} && ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_overlaps(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -8005,15 +9292,39 @@ var renderStandardPlan = (plan, options3 = {}) => {
 };
 
 // src/standard/renderer.ts
-var make5 = (options3 = {}) => makeTrusted("standard", (plan) => renderStandardPlan(plan, options3));
+var RendererProto = {
+  pipe() {
+    return pipeArguments8(this, arguments);
+  }
+};
+var makeWithState = (state = {}) => {
+  const renderer = makeTrusted("standard", (plan) => renderStandardPlan(plan, state));
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [TypeId6]: {
+      casing: state.casing
+    },
+    withCasing: (override) => makeWithState({
+      ...state,
+      casing: merge(state.casing, override)
+    })
+  });
+};
+var make10 = (options3 = {}) => makeWithState({ valueMappings: options3.valueMappings });
 export {
+  exports_unique as Unique,
   exports_table2 as Table,
   exports_scalar as Scalar,
   exports_row_set as RowSet,
   exports_renderer as Renderer,
   exports_query as Query,
+  exports_primary_key as PrimaryKey,
+  exports_json as Json,
+  exports_standard as Index,
   exports_function as Function,
+  exports_foreign_key as ForeignKey,
   exports_executor as Executor,
   exports_datatypes as Datatypes,
-  exports_column as Column
+  exports_column as Column,
+  exports_check as Check,
+  exports_cast as Cast
 };