effect-qb 0.19.0 → 0.20.0

package/dist/sqlite.js

@@ -22,7 +22,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
@@ -35,12 +35,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) => {
@@ -48,7 +217,7 @@ var attachPipe = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments(value, arguments);
+      return pipeArguments2(value, arguments);
     }
   });
   return value;
@@ -85,7 +254,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;
@@ -127,7 +296,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}`;
@@ -160,7 +329,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casi
     schemaName,
     casing
   };
-  return bound;
+  return withJsonPathAccess(bound);
 };
 
 // src/internal/column.ts
@@ -245,7 +414,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,
@@ -309,7 +478,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);
@@ -362,11 +531,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();
@@ -395,32 +564,800 @@ var canonicalizeDecimalString = (input) => {
     if (integer === "0") {
       return "0";
     }
-    return `${sign}${integer}`;
-  }
-  return `${sign}${integer}.${fraction}`;
-};
-var isCanonicalDecimalString = (value) => {
-  try {
-    return canonicalizeDecimalString(value) === value;
-  } catch {
-    return false;
+    return `${sign}${integer}`;
+  }
+  return `${sign}${integer}.${fraction}`;
+};
+var isCanonicalDecimalString = (value) => {
+  try {
+    return canonicalizeDecimalString(value) === value;
+  } catch {
+    return false;
+  }
+};
+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/sqlite/datatypes/index.ts
+var exports_datatypes = {};
+__export(exports_datatypes, {
+  sqliteDatatypes: () => sqliteDatatypes
+});
+
+// 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 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/sqlite/datatypes/index.ts
-var exports_datatypes = {};
-__export(exports_datatypes, {
-  sqliteDatatypes: () => sqliteDatatypes
-});
-
-// src/sqlite/datatypes/spec.ts
+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",
@@ -513,11 +1450,20 @@ var sqliteDatatypeKinds = {
   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/sqlite/datatypes/spec.ts
+var sqliteDatatypeFamilies2 = sqliteDatatypeFamilies;
+var sqliteDatatypeKinds2 = sqliteDatatypeKinds;
 
 // src/sqlite/datatypes/index.ts
 var withMetadata = (kind) => {
-  const kindSpec = sqliteDatatypeKinds[kind];
-  const familySpec = sqliteDatatypeFamilies[kindSpec.family];
+  const kindSpec = sqliteDatatypeKinds2[kind];
+  const familySpec = sqliteDatatypeFamilies2[kindSpec.family];
   return {
     dialect: "sqlite",
     kind,
@@ -525,6 +1471,7 @@ var withMetadata = (kind) => {
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: familySpec.implicitTargets,
     traits: familySpec?.traits
   };
 };
@@ -545,7 +1492,7 @@ var sqliteDatatypeModule = {
     }
   })
 };
-for (const kind of Object.keys(sqliteDatatypeKinds)) {
+for (const kind of Object.keys(sqliteDatatypeKinds2)) {
   sqliteDatatypeModule[kind] = () => withMetadata(kind);
 }
 sqliteDatatypeModule.json = () => ({
@@ -655,7 +1602,7 @@ var findSqliteErrorDescriptorsByNumberLoose = (number) => isSqliteErrorNumber(nu
 var isRecord = (value) => typeof value === "object" && value !== null;
 var unwrapSqliteDriverCause = (cause) => {
   let current = cause;
-  while (isRecord(current) && "_tag" in current && current._tag === "SqlError" && "cause" in current) {
+  while (isRecord(current) && "_tag" in current && "cause" in current) {
     current = current.cause;
   }
   return current;
@@ -808,65 +1755,34 @@ var narrowSqliteDriverErrorForReadQuery = (error) => {
 // src/sqlite/json.ts
 var exports_json = {};
 __export(exports_json, {
-  wildcard: () => wildcard2,
   typeOf: () => typeOf,
-  traverseText: () => traverseText,
-  traverse: () => traverse,
-  toJsonb: () => toJsonb,
-  toJson: () => toJson,
-  text: () => text,
   stripNulls: () => stripNulls,
-  slice: () => slice2,
-  set: () => set2,
-  remove: () => remove,
   pathMatch: () => pathMatch,
-  pathExists: () => pathExists,
-  path: () => path2,
-  merge: () => merge2,
   length: () => length,
-  keys: () => keys,
-  keyExists: () => keyExists,
-  key: () => key2,
-  json: () => json,
-  insert: () => insert,
-  index: () => index4,
-  hasKey: () => hasKey,
-  hasAnyKeys: () => hasAnyKeys,
-  hasAllKeys: () => hasAllKeys,
-  get: () => get,
-  descend: () => descend2,
-  delete_: () => delete_,
-  delete: () => delete_,
-  contains: () => contains,
-  containedBy: () => containedBy,
-  concat: () => concat,
-  buildObject: () => buildObject,
-  buildArray: () => buildArray,
-  accessText: () => accessText,
-  access: () => access
+  insert: () => insert
 });
 
 // src/sqlite/internal/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) => {
@@ -874,35 +1790,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 normalize2 = (expression) => (() => {
   const sql = render(expression);
   try {
@@ -997,7 +1913,7 @@ var collectInlineOptions = (fields2) => {
   return options;
 };
 var resolvePrimaryKeyColumns = (fields2, declaredOptions) => {
-  const inline = Object.entries(fields2).filter(([, column]) => column.metadata.primaryKey).map(([key]) => key);
+  const inline = Object.entries(fields2).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 [];
@@ -1023,8 +1939,8 @@ var validateOptions = (tableName, fields2, 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;
             }
           }
@@ -1071,10 +1987,10 @@ var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeyS
 var deriveSchema = (variant, tableName, fields2, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
   const structFields = {};
-  for (const [key, column] of Object.entries(fields2)) {
-    const schema2 = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+  for (const [key2, column] of Object.entries(fields2)) {
+    const schema2 = fieldSchemaForVariant(variant, column, tableName, key2, primaryKeySet);
     if (schema2 !== undefined) {
-      structFields[key] = schema2;
+      structFields[key2] = schema2;
     }
   }
   return Schema5.Struct(structFields);
@@ -1084,7 +2000,7 @@ var deriveInsertSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema
 var deriveUpdateSchema = (tableName, fields2, primaryKeyColumns) => deriveSchema("update", tableName, fields2, 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;
@@ -1125,15 +2041,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) => {
@@ -1141,21 +2058,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, fields2, declaredOptions, schemaName, casing) => {
   const normalizedOptions = [...collectInlineOptions(fields2), ...declaredOptions];
   validateFieldDialects(name, fields2);
   validateOptions(name, fields2, declaredOptions);
   const primaryKey2 = resolvePrimaryKeyColumns(fields2, declaredOptions);
-  const columns = Object.fromEntries(Object.entries(fields2).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName, casing)]));
+  const conflictArbiters = conflictArbitersFromOptions(normalizedOptions);
+  const columns = Object.fromEntries(Object.entries(fields2).map(([key2, column]) => [key2, bindColumn(name, key2, column, name, schemaName, casing)]));
   return {
     columns,
     normalizedOptions,
-    primaryKey: primaryKey2
+    primaryKey: primaryKey2,
+    conflictArbiters
   };
 };
 var getSchemaCache = (table) => {
@@ -1171,7 +2117,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);
@@ -1240,16 +2186,17 @@ var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema
   table.name = name;
   table.columns = artifacts.columns;
   defineSchemasGetter(table);
-  table[TypeId6] = {
+  table[TypeId7] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields: fields2,
     primaryKey: artifacts.primaryKey,
+    conflictArbiters: artifacts.conflictArbiters,
     kind,
     casing
   };
-  table[TypeId3] = {
+  table[TypeId4] = {
     selection: artifacts.columns,
     required: undefined,
     available: {
@@ -1263,8 +2210,8 @@ var makeTable = (name, fields2, 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
     });
@@ -1302,13 +2249,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,
@@ -1317,42 +2265,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, fields2, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields2, [], 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: {
@@ -1362,12 +2326,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
     });
@@ -1386,18 +2350,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(fields2), ...declaredOptions];
         return {
           name,
           baseName: name,
           schemaName: resolvedSchemaName,
           fields: fields2,
           primaryKey: resolvePrimaryKeyColumns(fields2, collectInlineOptions(fields2)),
+          conflictArbiters: conflictArbitersFromOptions(normalizedOptions),
           kind: "schema"
         };
       }
-      static get [TypeId3]() {
+      static get [TypeId4]() {
         const artifacts = ensureClassArtifacts(this);
         return {
           selection: artifacts.columns,
@@ -1416,49 +2382,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(fields2)) {
-      Object.defineProperty(TableClassBase, key, {
+    for (const key2 of Object.keys(fields2)) {
+      Object.defineProperty(TableClassBase, key2, {
         enumerable: true,
         configurable: true,
         get() {
-          return ensureClassArtifacts(this).columns[key];
+          return ensureClassArtifacts(this).columns[key2];
         }
       });
     }
     return TableClassBase;
   };
 }
-var primaryKey2 = (columns) => makeOption({
-  kind: "primaryKey",
-  columns: normalizeColumnList(columns)
-});
-var unique2 = (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 primaryKey2(columns) {
+  return makeResolvedOption({
+    kind: "primaryKey",
+    columns: []
+  }, (table) => ({
+    kind: "primaryKey",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function unique2(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 isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1711,9 +2711,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;
@@ -1770,10 +2770,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" });
@@ -1798,17 +2798,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;
@@ -1816,59 +2816,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;
   }
 };
@@ -1950,35 +2950,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;
 };
@@ -1990,8 +2990,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),
@@ -2082,18 +3082,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;
@@ -2130,8 +3130,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) {
@@ -2342,12 +3342,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));
@@ -2368,12 +3368,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;
@@ -2406,12 +3406,12 @@ var guaranteedSourceNames = (assumptions) => analyzeFormula(assumptions).sourceN
 // 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");
@@ -2424,13 +3424,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] = {
@@ -2452,11 +3452,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,
@@ -2470,7 +3470,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;
@@ -2517,8 +3517,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) {
@@ -2530,7 +3530,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;
     }
@@ -2607,51 +3607,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;
@@ -2685,8 +3640,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(",");
@@ -2742,7 +3697,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)}`;
@@ -2750,7 +3705,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";
@@ -3013,7 +3968,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "createTable",
       select: {},
@@ -3041,7 +3996,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "dropTable",
       select: {},
@@ -3072,7 +4027,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "createIndex",
       select: {},
@@ -3105,7 +4060,7 @@ var makeDslTransactionDdlRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "dropIndex",
       select: {},
@@ -3159,7 +4114,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: sourceBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "insert",
       select: {},
@@ -3179,7 +4134,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;
@@ -3219,11 +4174,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
     }, {
@@ -3237,7 +4192,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;
@@ -3281,7 +4236,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required,
       available: ctx.mutationAvailableSources(target),
-      dialect: primaryTarget.source[TypeId3].dialect
+      dialect: primaryTarget.source[TypeId4].dialect
     }, {
       kind: "update",
       select: {},
@@ -3313,7 +4268,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: sourceBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "insert",
       select: {},
@@ -3347,7 +4302,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required: [],
       available: ctx.mutationAvailableSources(target),
-      dialect: primaryTarget.source[TypeId3].dialect
+      dialect: primaryTarget.source[TypeId4].dialect
     }, {
       kind: "delete",
       select: {},
@@ -3368,7 +4323,7 @@ var makeDslMutationRuntime = (ctx) => {
       selection: {},
       required: [],
       available: {},
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "truncate",
       select: {},
@@ -3422,7 +4377,7 @@ var makeDslMutationRuntime = (ctx) => {
           baseName: usingBaseName
         }
       },
-      dialect: target[TypeId3].dialect
+      dialect: target[TypeId4].dialect
     }, {
       kind: "merge",
       select: {},
@@ -3485,7 +4440,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 ?? []] : [];
@@ -3493,7 +4448,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,
@@ -3514,7 +4469,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);
@@ -3533,7 +4488,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") {
@@ -3600,7 +4555,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);
@@ -3619,7 +4574,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);
@@ -3639,7 +4594,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, {
@@ -3651,7 +4606,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);
@@ -3693,7 +4648,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);
@@ -3713,7 +4668,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({
@@ -3732,7 +4687,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({
@@ -3746,7 +4701,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);
@@ -3762,7 +4717,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);
@@ -3860,7 +4815,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);
@@ -3876,7 +4831,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({
@@ -3901,14 +4856,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(".");
@@ -3917,7 +4872,7 @@ var flattenSelection = (selection, path2 = []) => {
   const fields2 = [];
   for (const [key2, value] of Object.entries(selection)) {
     const nextPath = [...path2, key2];
-    if (isExpression2(value)) {
+    if (isExpression3(value)) {
       fields2.push({
         path: nextPath,
         expression: value,
@@ -3957,7 +4912,7 @@ var validateProjections = (projections) => {
 // src/internal/derived-table.ts
 var DerivedProto = {
   pipe() {
-    return pipeArguments5(this, arguments);
+    return pipeArguments6(this, arguments);
   }
 };
 var attachPipe4 = (value) => {
@@ -3965,7 +4920,7 @@ var attachPipe4 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments5(value, arguments);
+      return pipeArguments6(value, arguments);
     }
   });
   return value;
@@ -3991,7 +4946,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,
@@ -4016,7 +4971,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;
@@ -4029,7 +4984,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;
@@ -4043,9 +4998,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;
 };
@@ -4069,16 +5024,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),
@@ -4102,7 +5060,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,
@@ -4136,7 +5094,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,
@@ -4216,11 +5174,11 @@ 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) => makeExpression2({
   runtime: state.runtime,
   dbType: state.dbType,
   nullability: state.nullability,
@@ -4230,7 +5188,7 @@ var buildJsonNodeExpression = (expressions, state, ast) => makeExpression({
 }, ast);
 var jsonDbTypeOf = (base) => base[TypeId].dbType;
 var resolveJsonMergeDbType = (...values) => values.some((value) => value[TypeId].dbType.kind === "jsonb") ? jsonbDb : jsonDb;
-var makeJsonLiteralExpression = (value, dbType = jsonDb) => makeExpression({
+var makeJsonLiteralExpression = (value, dbType = jsonDb) => makeExpression2({
   runtime: value,
   dbType,
   nullability: value === null ? "always" : "never",
@@ -4565,7 +5523,7 @@ var jsonPathMatch = (base, query) => {
 };
 var json = {
   key,
-  index: index3,
+  index,
   wildcard,
   slice,
   descend,
@@ -4601,7 +5559,7 @@ var json = {
 };
 var jsonb = {
   key,
-  index: index3,
+  index,
   wildcard,
   slice,
   descend,
@@ -4652,7 +5610,7 @@ var toMutationValueExpression = (value, column) => {
     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,
@@ -4669,7 +5627,7 @@ var toMutationValueExpression = (value, column) => {
     return retargetLiteralExpression(value, column);
   }
   const normalizedValue = normalizeMutationValue(value);
-  return makeExpression({
+  return makeExpression2({
     runtime: normalizedValue,
     dbType: columnState.dbType,
     runtimeSchema: columnState.runtimeSchema,
@@ -4684,15 +5642,15 @@ var toMutationValueExpression = (value, column) => {
   });
 };
 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;
@@ -4705,7 +5663,7 @@ 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,
@@ -4759,7 +5717,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]) => ({
@@ -4924,59 +5882,29 @@ var {
   normalizeColumnList,
   defaultIndexName
 });
+
 // src/sqlite/json.ts
-var key2 = json.key;
-var index4 = json.index;
-var wildcard2 = json.wildcard;
-var slice2 = json.slice;
-var descend2 = json.descend;
-var path2 = json.path;
-var get = json.get;
-var access = json.access;
-var traverse = json.traverse;
-var text = json.text;
-var accessText = json.accessText;
-var traverseText = json.traverseText;
-var contains = json.contains;
-var containedBy = json.containedBy;
-var hasKey = json.hasKey;
-var keyExists = json.keyExists;
-var hasAnyKeys = json.hasAnyKeys;
-var hasAllKeys = json.hasAllKeys;
-var delete_ = json.delete;
-var remove = json.remove;
-var set2 = json.set;
 var insert = json.insert;
-var concat = json.concat;
-var merge2 = json.merge;
-var buildObject = json.buildObject;
-var buildArray = json.buildArray;
-var toJson = json.toJson;
-var toJsonb = json.toJsonb;
 var typeOf = json.typeOf;
 var length = json.length;
-var keys = json.keys;
 var stripNulls = json.stripNulls;
-var pathExists = json.pathExists;
 var pathMatch = json.pathMatch;
 // src/sqlite/executor.ts
 var exports_executor2 = {};
 __export(exports_executor2, {
   withTransaction: () => withTransaction2,
-  withSavepoint: () => withSavepoint2,
   make: () => make4,
   driver: () => driver2,
   custom: () => custom3
 });
 import * as Effect2 from "effect/Effect";
-import * as SqlClient3 from "@effect/sql/SqlClient";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
 import * as Stream2 from "effect/Stream";
 
 // src/internal/executor.ts
 var exports_executor = {};
 __export(exports_executor, {
   withTransaction: () => withTransaction,
-  withSavepoint: () => withSavepoint,
   streamFromSqlClient: () => streamFromSqlClient,
   remapRows: () => remapRows,
   makeRowDecoder: () => makeRowDecoder,
@@ -4990,9 +5918,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
@@ -5039,9 +5968,9 @@ var mappingCandidates = (context) => {
     runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
   ];
 };
-var findMapping = (context, key3) => {
+var findMapping = (context, key2) => {
   for (const candidate of mappingCandidates(context)) {
-    const value = candidate?.[key3];
+    const value = candidate?.[key2];
     if (value !== undefined) {
       return value;
     }
@@ -5169,7 +6098,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":
@@ -5197,14 +6126,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":
@@ -5222,7 +6148,7 @@ var runtimeSchemaForDbType = (dbType) => {
     return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
     return Schema8.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
@@ -5242,27 +6168,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, key3) => {
+var propertyAstOf = (ast, key2) => {
   switch (ast._tag) {
-    case "Transformation":
-      return propertyAstOf(SchemaAST.typeAST(ast), key3);
-    case "Refinement":
-      return propertyAstOf(ast.from, key3);
     case "Suspend":
-      return propertyAstOf(ast.f(), key3);
-    case "TypeLiteral": {
-      const property = ast.propertySignatures.find((entry) => entry.name === key3);
+      return propertyAstOf(ast.thunk(), key2);
+    case "Objects": {
+      const property = ast.propertySignatures.find((entry) => entry.name === key2);
       if (property !== undefined) {
         return property.type;
       }
-      const index5 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
-      return index5?.type;
+      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "String");
+      return index4?.type;
     }
     case "Union": {
       const values2 = ast.types.flatMap((member) => {
-        const next = propertyAstOf(member, key3);
+        const next = propertyAstOf(member, key2);
         return next === undefined ? [] : [next];
       });
       return unionAst(values2);
@@ -5271,27 +6193,23 @@ var propertyAstOf = (ast, key3) => {
       return;
   }
 };
-var numberAstOf = (ast, index5) => {
+var numberAstOf = (ast, index4) => {
   switch (ast._tag) {
-    case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index5);
-    case "Refinement":
-      return numberAstOf(ast.from, index5);
     case "Suspend":
-      return numberAstOf(ast.f(), index5);
-    case "TupleType": {
-      const element = ast.elements[index5];
+      return numberAstOf(ast.thunk(), index4);
+    case "Arrays": {
+      const element = ast.elements[index4];
       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, index5);
+        const next = numberAstOf(member, index4);
         return next === undefined ? [] : [next];
       });
       return unionAst(values2);
@@ -5302,7 +6220,7 @@ var numberAstOf = (ast, index5) => {
 };
 var exactJsonSegments = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index");
 var schemaAstAtExactJsonPath = (schema2, segments) => {
-  let current = SchemaAST.typeAST(schema2.ast);
+  let current = schema2.ast;
   for (const segment of segments) {
     if (segment.kind === "key") {
       const property = propertyAstOf(current, segment.key);
@@ -5332,28 +6250,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;
   }
@@ -5362,14 +6280,14 @@ var jsonCompatibleSchema = (schema2) => {
   if (schema2 === undefined) {
     return;
   }
-  const ast = SchemaAST.typeAST(schema2.ast);
+  const ast = SchemaAST.toType(schema2.ast);
   return isJsonCompatibleAst(ast) ? schema2 : JsonValueSchema;
 };
 var buildStructSchema = (entries, context) => {
   const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
   return Schema8.Struct(fields2);
 };
-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([
@@ -5522,20 +6440,20 @@ var expressionRuntimeSchema = (expression, context) => {
 };
 
 // src/internal/executor.ts
-var setPath2 = (target, path3, value) => {
+var setPath2 = (target, path2, value) => {
   let current = target;
-  for (let index5 = 0;index5 < path3.length - 1; index5++) {
-    const key3 = path3[index5];
-    const existing = current[key3];
+  for (let index4 = 0;index4 < path2.length - 1; index4++) {
+    const key2 = path2[index4];
+    const existing = current[key2];
     if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
       current = existing;
       continue;
     }
     const next = {};
-    current[key3] = next;
+    current[key2] = next;
     current = next;
   }
-  current[path3[path3.length - 1]] = value;
+  current[path2[path2.length - 1]] = value;
 };
 var hasWriteStatement = (statement) => statement === "insert" || statement === "update" || statement === "delete" || statement === "truncate" || statement === "merge" || statement === "transaction" || statement === "commit" || statement === "rollback" || statement === "savepoint" || statement === "rollbackTo" || statement === "releaseSavepoint" || statement === "createTable" || statement === "createIndex" || statement === "dropIndex" || statement === "dropTable";
 var hasWriteCapabilityInSource = (source) => typeof source === "object" && source !== null && ("plan" in source) ? hasWriteCapability(source.plan) : false;
@@ -5575,24 +6493,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");
@@ -5604,11 +6529,11 @@ var effectiveRuntimeNullability = (expression, scope) => {
     return "always";
   }
   if (ast.kind === "column") {
-    const key3 = columnPredicateKey(ast.tableName, ast.columnName);
-    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key3)) {
+    const key2 = columnPredicateKey(ast.tableName, ast.columnName);
+    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key2)) {
       return "always";
     }
-    if (scope.nonNullKeys.has(key3)) {
+    if (scope.nonNullKeys.has(key2)) {
       return "never";
     }
   }
@@ -5635,8 +6560,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);
@@ -5662,18 +6587,22 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
   if (Schema9.is(schema2)(normalized)) {
     return normalized;
   }
-  try {
-    return Schema9.decodeUnknownSync(schema2)(normalized);
-  } catch (cause) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  const decoded = Schema9.decodeUnknownExit(schema2)(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) {
@@ -5691,7 +6620,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);
@@ -5729,12 +6658,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)))));
@@ -5743,12 +6672,11 @@ 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/internal/renderer.ts
 var TypeId10 = Symbol.for("effect-qb/Renderer");
-var projectionPathKey = (path3) => JSON.stringify(path3);
-var formatProjectionPath2 = (path3) => path3.join(".");
+var projectionPathKey = (path2) => JSON.stringify(path2);
+var formatProjectionPath2 = (path2) => path2.join(".");
 var validateProjectionPathsMatchSelection = (plan, projections) => {
   const expected = flattenSelection(getAst(plan).select);
   const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
@@ -5807,14 +6735,15 @@ var renderDbTypeName = (value) => value;
 // src/internal/dialect-renderers/sqlite.ts
 import * as Schema10 from "effect/Schema";
 var renderDbType = (dialect, dbType) => {
-  if (dialect.name === "sqlite" && dbType.kind === "uuid") {
-    return "text";
-  }
-  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 !== "sqlite") {
     return renderDbTypeName(kind);
   }
@@ -5887,7 +6816,7 @@ var renderSqliteMutationLimit = (expression, state, dialect) => {
   }
   return renderExpression(expression, state, dialect);
 };
-var casingForTable = (table, state) => merge(state.casing, table[TypeId6].casing);
+var casingForTable = (table, state) => merge(state.casing, table[TypeId7].casing);
 var casedColumnName = (columnName, state, tableName) => {
   if (tableName !== undefined) {
     const mapped = state.sourceNames?.get(tableName)?.columns.get(columnName);
@@ -5899,7 +6828,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);
@@ -5912,9 +6841,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) => [
@@ -5982,11 +6911,11 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
   const normalizedIfNotExists = normalizeStatementFlag(ifNotExists);
   const table = targetSource.source;
   const tableCasing = casingForTable(table, state);
-  const fields2 = table[TypeId6].fields;
+  const fields2 = table[TypeId7].fields;
   const definitions = Object.entries(fields2).map(([columnName, column]) => renderColumnDefinition(dialect, state, columnName, column, targetSource.tableName, tableCasing));
   const options2 = table[OptionsSymbol];
   const tableOptions = Array.isArray(options2) ? options2 : [options2];
-  validateOptions(table[TypeId6].name, fields2, tableOptions);
+  validateOptions(table[TypeId7].name, fields2, tableOptions);
   for (const option2 of tableOptions) {
     if (typeof option2 !== "object" || option2 === null || !("kind" in option2)) {
       continue;
@@ -6039,9 +6968,9 @@ var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
   const tableCasing = casingForTable(table, state);
   return dialect.name === "postgres" || dialect.name === "sqlite" ? `drop index${ifExists ? " if exists" : ""} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))}` : `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 isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId in value);
 var isJsonDbType2 = (dbType) => dbType.kind === "jsonb" || dbType.kind === "json" || ("variant" in dbType) && dbType.variant === "json";
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType2(value[TypeId].dbType);
+var isJsonExpression2 = (value) => isExpression4(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) => {
@@ -6058,7 +6987,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") {
@@ -6074,8 +7003,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 index4 = segment.index;
+      return typeof index4 === "number" && Number.isFinite(index4);
     }
     case "wildcard":
     case "descend":
@@ -6096,12 +7025,12 @@ var validateJsonPathSegments = (segments) => {
   return segments;
 };
 var extractJsonPathSegments = (node) => {
-  const path3 = node.path ?? node.segments ?? node.keys;
-  if (isJsonPathValue2(path3)) {
-    return validateJsonPathSegments(path3.segments);
+  const path2 = node.path ?? node.segments ?? node.keys;
+  if (isJsonPathValue2(path2)) {
+    return validateJsonPathSegments(path2.segments);
   }
-  if (Array.isArray(path3)) {
-    return validateJsonPathSegments(path3);
+  if (Array.isArray(path2)) {
+    return validateJsonPathSegments(path2);
   }
   if (node.segments !== undefined) {
     return validateJsonPathSegments(node.segments);
@@ -6115,7 +7044,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];
@@ -6152,7 +7081,7 @@ var renderJsonPathSegment = (segment) => {
       throw new Error("Unsupported JSON path segment");
   }
 };
-var renderSqliteJsonIndex = (index5) => index5 >= 0 ? String(index5) : `#${index5}`;
+var renderSqliteJsonIndex = (index4) => index4 >= 0 ? String(index4) : `#${index4}`;
 var renderSqliteJsonPathSegment = (segment) => {
   if (typeof segment === "number") {
     return `[${renderSqliteJsonIndex(segment)}]`;
@@ -6172,11 +7101,11 @@ var renderSqliteJsonPathSegment = (segment) => {
   return renderJsonPathSegment(segment);
 };
 var renderJsonPathStringLiteral = (segments, renderSegment = renderJsonPathSegment) => {
-  let path3 = "$";
+  let path2 = "$";
   for (const segment of segments) {
-    path3 += renderSegment(segment);
+    path2 += renderSegment(segment);
   }
-  return path3;
+  return path2;
 };
 var renderSqliteJsonPath = (segments, state, dialect) => dialect.renderLiteral(renderJsonPathStringLiteral(segments, renderSqliteJsonPathSegment), state);
 var isJsonArrayIndexSegment = (segment) => typeof segment === "number" || typeof segment === "object" && segment !== null && segment.kind === "index";
@@ -6208,7 +7137,7 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression3(value)) {
+  if (!isExpression4(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression(value, state, dialect);
@@ -6259,7 +7188,7 @@ var renderJsonOpaquePath = (value, state, dialect) => {
     }
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression3(value)) {
+  if (isExpression4(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");
@@ -6313,8 +7242,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":
@@ -6324,7 +7253,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const baseSql = renderExpression(base, state, dialect);
@@ -6347,24 +7276,24 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression(base, state, dialect);
-      const keys2 = extractJsonKeys(ast, segments);
-      if (keys2.length === 0) {
+      const keys = extractJsonKeys(ast, segments);
+      if (keys.length === 0) {
         return;
       }
-      if (keys2.some((key3) => typeof key3 !== "string" || key3.length === 0)) {
+      if (keys.some((key2) => typeof key2 !== "string" || key2.length === 0)) {
         throw new Error("json key predicates require string keys");
       }
-      const keyNames = keys2;
+      const keyNames = keys;
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| array[${keyNames.map((key3) => renderPostgresTextLiteral(key3, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?| array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& array[${keyNames.map((key3) => renderPostgresTextLiteral(key3, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?& array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
         }
         return `(${baseSql} ? ${renderPostgresTextLiteral(keyNames[0], state, dialect)})`;
       }
@@ -6377,7 +7306,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
+      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6414,7 +7343,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6425,7 +7354,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6436,7 +7365,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6448,7 +7377,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6467,7 +7396,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6482,7 +7411,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6493,7 +7422,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -6511,11 +7440,11 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue(ast);
-      if (!isExpression3(nextValue)) {
+      if (!isExpression4(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -6535,39 +7464,39 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
-      const path3 = ast.path ?? ast.query ?? ast.right;
-      if (path3 === undefined) {
+      const path2 = ast.path ?? ast.query ?? ast.right;
+      if (path2 === undefined) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `(${renderPostgresJsonValue(base, state, dialect)} @? ${renderJsonOpaquePath(path3, state, dialect)})`;
+        return `(${renderPostgresJsonValue(base, state, dialect)} @? ${renderJsonOpaquePath(path2, state, dialect)})`;
       }
       if (dialect.name === "sqlite") {
-        return `(json_type(${renderExpression(base, state, dialect)}, ${renderJsonOpaquePath(path3, state, dialect)}) is not null)`;
+        return `(json_type(${renderExpression(base, state, dialect)}, ${renderJsonOpaquePath(path2, state, dialect)}) is not null)`;
       }
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
-      const path3 = ast.path ?? ast.query ?? ast.right;
-      if (path3 === undefined) {
+      const path2 = ast.path ?? ast.query ?? ast.right;
+      if (path2 === undefined) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `(${renderPostgresJsonValue(base, state, dialect)} @@ ${renderJsonOpaquePath(path3, state, dialect)})`;
+        return `(${renderPostgresJsonValue(base, state, dialect)} @@ ${renderJsonOpaquePath(path2, state, dialect)})`;
       }
       unsupportedJsonFeature(dialect, "jsonPathMatch");
     }
   }
   return;
 };
-var selectionProjections = (selection) => flattenSelection(selection).map(({ path: path3, alias: alias2 }) => ({
-  path: path3,
+var selectionProjections = (selection) => flattenSelection(selection).map(({ path: path2, alias: alias2 }) => ({
+  path: path2,
   alias: alias2
 }));
 var renderMutationAssignment = (entry, state, dialect, targetTableName) => {
@@ -6698,18 +7627,18 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
         const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
-          const fields2 = table[TypeId6].fields;
+          const fields2 = table[TypeId7].fields;
           const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields2[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const table = targetSource.source;
-          const fields2 = table[TypeId6].fields;
+          const fields2 = table[TypeId7].fields;
           const encodedValues = insertSource.values.map((entry) => ({
             columnName: entry.columnName,
             values: encodeArrayValues(entry.values, fields2[entry.columnName], state, dialect)
           }));
           const rowCount = encodedValues[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index5) => `(${encodedValues.map((entry) => dialect.renderLiteral(entry.values[index5], state)).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index4) => `(${encodedValues.map((entry) => dialect.renderLiteral(entry.values[index4], state)).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -6851,25 +7780,25 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       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 ${renderExpression(merge3.on, state, dialect)}`;
-      if (merge3.whenMatched) {
+      const merge2 = 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 ${renderExpression(merge2.on, state, dialect)}`;
+      if (merge2.whenMatched) {
         sql += " when matched";
-        if (merge3.whenMatched.predicate) {
-          sql += ` and ${renderExpression(merge3.whenMatched.predicate, state, dialect)}`;
+        if (merge2.whenMatched.predicate) {
+          sql += ` and ${renderExpression(merge2.whenMatched.predicate, state, dialect)}`;
         }
-        if (merge3.whenMatched.kind === "delete") {
+        if (merge2.whenMatched.kind === "delete") {
           sql += " then delete";
         } else {
-          sql += ` then update set ${merge3.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
+          sql += ` then update set ${merge2.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge3.whenNotMatched) {
+      if (merge2.whenNotMatched) {
         sql += " when not matched";
-        if (merge3.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression(merge3.whenNotMatched.predicate, state, dialect)}`;
+        if (merge2.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression(merge2.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge3.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge3.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge2.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge2.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -6930,7 +7859,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 }, (_, index4) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index4]])));
     return renderSelectRows(rows, columnNames);
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
@@ -6988,10 +7917,10 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     const columnNames = Object.keys(tableFunction.columns);
     return `${functionName}(${tableFunction.args.map((arg) => renderExpression(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 ? source[TypeId6].schemaName : undefined;
-  if (typeof source === "object" && source !== null && TypeId6 in source) {
+  const schemaName = typeof source === "object" && source !== null && TypeId7 in source ? source[TypeId7].schemaName : undefined;
+  if (typeof source === "object" && source !== null && 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", baseTableName);
     const renderedBaseName = applyCategory(casing, "tables", baseTableName);
@@ -7088,8 +8017,8 @@ var renderExpression = (expression, state, dialect) => {
     case "contains": {
       const [leftExpression, rightExpression] = expectBinaryExpressions("contains", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
         return `(${left} @> ${right})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -7097,8 +8026,8 @@ var renderExpression = (expression, state, dialect) => {
     case "containedBy": {
       const [leftExpression, rightExpression] = expectBinaryExpressions("containedBy", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
         return `(${left} <@ ${right})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -7106,8 +8035,8 @@ var renderExpression = (expression, state, dialect) => {
     case "overlaps": {
       const [leftExpression, rightExpression] = expectBinaryExpressions("overlaps", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
-        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression(rightExpression, state, dialect);
         return `(${left} && ${right})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -7196,14 +8125,15 @@ var renderExpression = (expression, state, dialect) => {
 // src/internal/dialect-renderers/postgres.ts
 import * as Schema11 from "effect/Schema";
 var renderDbType2 = (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 isArrayDbType2 = (dbType) => ("element" in dbType);
 var renderCastType2 = (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);
   }
@@ -7225,13 +8155,13 @@ var renderCastType2 = (dialect, dbType) => {
       return renderDbTypeName(kind);
   }
 };
-var casingForTable2 = (table, state) => merge(state.casing, table[TypeId6].casing);
+var casingForTable2 = (table, state) => merge(state.casing, table[TypeId7].casing);
 var casedTableName = (table, state) => {
-  const tableState = table[TypeId6];
+  const tableState = table[TypeId7];
   return applyCategory(casingForTable2(table, state), "tables", tableState.baseName);
 };
 var casedSchemaName = (table, state) => {
-  const schemaName = table[TypeId6].schemaName;
+  const schemaName = table[TypeId7].schemaName;
   return schemaName === undefined ? undefined : applyCategory(casingForTable2(table, state), "schemas", schemaName);
 };
 var casedColumnName2 = (columnName, state, tableName) => {
@@ -7245,7 +8175,7 @@ var casedColumnName2 = (columnName, state, tableName) => {
 };
 var casedTableReferenceName2 = (tableName, state) => state.sourceNames?.get(tableName)?.tableName ?? applyCategory(state.casing, "tables", tableName);
 var quoteColumn2 = (columnName, state, dialect, tableName) => dialect.quoteIdentifier(casedColumnName2(columnName, state, tableName));
-var stateWithTableCasing2 = (state, source) => typeof source === "object" && source !== null && (TypeId6 in source) ? { ...state, casing: casingForTable2(source, state) } : state;
+var stateWithTableCasing2 = (state, source) => typeof source === "object" && source !== null && (TypeId7 in source) ? { ...state, casing: casingForTable2(source, state) } : state;
 var referenceCasing2 = (reference, state) => merge(state.casing, reference.casing);
 var renderReferenceTable2 = (reference, state, dialect) => {
   const casing = referenceCasing2(reference, state);
@@ -7258,9 +8188,9 @@ var registerSourceReference2 = (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 = casingForTable2(table, state);
     const renderedTableName = tableState.kind === "alias" ? tableName : applyCategory(casing, "tables", tableState.baseName);
     const columns = new Map(Object.keys(tableState.fields).map((columnName) => [
@@ -7374,11 +8304,11 @@ var renderCreateTableSql2 = (targetSource, state, dialect, ifNotExists) => {
   }
   const table = targetSource.source;
   const tableCasing = casingForTable2(table, state);
-  const fields2 = table[TypeId6].fields;
+  const fields2 = table[TypeId7].fields;
   const definitions = Object.entries(fields2).map(([columnName, column]) => renderColumnDefinition2(dialect, state, columnName, column, targetSource.tableName, tableCasing));
   const options2 = table[OptionsSymbol];
   const tableOptions = Array.isArray(options2) ? options2 : [options2];
-  validateOptions(table[TypeId6].name, fields2, tableOptions);
+  validateOptions(table[TypeId7].name, fields2, tableOptions);
   for (const option2 of tableOptions) {
     if (typeof option2 !== "object" || option2 === null || !("kind" in option2)) {
       continue;
@@ -7437,8 +8367,8 @@ var renderDropIndexSql2 = (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 : casingForTable2(table2, state);
     const renderedSchemaName = table2 === undefined ? schemaName : casedSchemaName(table2, state);
     const renderedIndexName = applyCategory(tableCasing2, "indexes", name);
@@ -7449,7 +8379,7 @@ var renderDropIndexSql2 = (targetSource, ddl, state, dialect) => {
   const tableCasing = casingForTable2(table, state);
   return `drop index ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
 };
-var isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId in value);
+var isExpression5 = (value) => value !== null && typeof value === "object" && (TypeId in value);
 var isJsonDbType3 = (dbType) => {
   if (dbType.kind === "jsonb" || dbType.kind === "json") {
     return true;
@@ -7460,7 +8390,7 @@ var isJsonDbType3 = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var isJsonExpression2 = (value) => isExpression4(value) && isJsonDbType3(value[TypeId].dbType);
+var isJsonExpression3 = (value) => isExpression5(value) && isJsonDbType3(value[TypeId].dbType);
 var expectValueExpression2 = (_functionName, value) => value;
 var expectBinaryExpressions2 = (_functionName, left, right) => [left, right];
 var renderBinaryExpression2 = (functionName, operator, left, right, state, dialect) => {
@@ -7507,7 +8437,7 @@ var unsupportedJsonFeature2 = (dialect, feature) => {
   throw error;
 };
 var extractJsonBase2 = (node) => node.value ?? node.base ?? node.input ?? node.left ?? node.target;
-var isJsonPathValue3 = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isJsonPathValue3 = (value) => value !== null && typeof value === "object" && (TypeId3 in value);
 var isOptionalJsonPathNumber2 = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
 var isJsonPathSegment2 = (segment) => {
   if (typeof segment === "string") {
@@ -7523,8 +8453,8 @@ var isJsonPathSegment2 = (segment) => {
     case "key":
       return typeof segment.key === "string";
     case "index": {
-      const index5 = segment.index;
-      return typeof index5 === "number" && Number.isFinite(index5);
+      const index4 = segment.index;
+      return typeof index4 === "number" && Number.isFinite(index4);
     }
     case "wildcard":
     case "descend":
@@ -7545,12 +8475,12 @@ var validateJsonPathSegments2 = (segments) => {
   return segments;
 };
 var extractJsonPathSegments2 = (node) => {
-  const path3 = node.path ?? node.segments ?? node.keys;
-  if (isJsonPathValue3(path3)) {
-    return validateJsonPathSegments2(path3.segments);
+  const path2 = node.path ?? node.segments ?? node.keys;
+  if (isJsonPathValue3(path2)) {
+    return validateJsonPathSegments2(path2.segments);
   }
-  if (Array.isArray(path3)) {
-    return validateJsonPathSegments2(path3);
+  if (Array.isArray(path2)) {
+    return validateJsonPathSegments2(path2);
   }
   if (node.segments !== undefined) {
     return validateJsonPathSegments2(node.segments);
@@ -7564,7 +8494,7 @@ var extractJsonPathSegments2 = (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];
@@ -7602,11 +8532,11 @@ var renderJsonPathSegment2 = (segment) => {
   }
 };
 var renderJsonPathStringLiteral2 = (segments) => {
-  let path3 = "$";
+  let path2 = "$";
   for (const segment of segments) {
-    path3 += renderJsonPathSegment2(segment);
+    path2 += renderJsonPathSegment2(segment);
   }
-  return path3;
+  return path2;
 };
 var renderMySqlJsonPath = (segments, state, dialect) => dialect.renderLiteral(renderJsonPathStringLiteral2(segments), state);
 var renderPostgresJsonPathArray2 = (segments, state, dialect) => `array[${segments.map((segment) => {
@@ -7637,7 +8567,7 @@ var renderPostgresJsonAccessStep2 = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue2 = (value, state, dialect) => {
-  if (!isExpression4(value)) {
+  if (!isExpression5(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression2(value, state, dialect);
@@ -7681,7 +8611,7 @@ var renderJsonOpaquePath2 = (value, state, dialect) => {
     }
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression4(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");
@@ -7731,8 +8661,8 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
   const base = extractJsonBase2(ast);
   const segments = extractJsonPathSegments2(ast);
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index");
-  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression2(expression) ? renderPostgresJsonKind2(expression) : undefined;
-  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression2(base) ? renderPostgresJsonKind2(base) : undefined;
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression3(expression) ? renderPostgresJsonKind2(expression) : undefined;
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression3(base) ? renderPostgresJsonKind2(base) : undefined;
   switch (kind) {
     case "jsonGet":
     case "jsonPath":
@@ -7742,7 +8672,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       const baseSql = renderExpression2(base, state, dialect);
@@ -7765,24 +8695,24 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue2(base, state, dialect) : renderExpression2(base, state, dialect);
-      const keys2 = extractJsonKeys2(ast, segments);
-      if (keys2.length === 0) {
+      const keys = extractJsonKeys2(ast, segments);
+      if (keys.length === 0) {
         return;
       }
-      if (keys2.some((key3) => typeof key3 !== "string" || key3.length === 0)) {
+      if (keys.some((key2) => typeof key2 !== "string" || key2.length === 0)) {
         throw new Error("json key predicates require string keys");
       }
-      const keyNames = keys2;
+      const keyNames = keys;
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| array[${keyNames.map((key3) => renderPostgresTextLiteral2(key3, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?| array[${keyNames.map((key2) => renderPostgresTextLiteral2(key2, state, dialect)).join(", ")}])`;
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& array[${keyNames.map((key3) => renderPostgresTextLiteral2(key3, state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?& array[${keyNames.map((key2) => renderPostgresTextLiteral2(key2, state, dialect)).join(", ")}])`;
         }
         return `(${baseSql} ? ${renderPostgresTextLiteral2(keyNames[0], state, dialect)})`;
       }
@@ -7795,7 +8725,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
+      if (!isExpression5(ast.left) || !isExpression5(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7832,7 +8762,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7843,7 +8773,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7854,7 +8784,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7866,7 +8796,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7881,7 +8811,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7895,7 +8825,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7906,7 +8836,7 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -7924,11 +8854,11 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression5(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue2(ast);
-      if (!isExpression4(nextValue)) {
+      if (!isExpression5(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -7945,39 +8875,39 @@ var renderJsonExpression2 = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
-      const path3 = ast.path ?? ast.query ?? ast.right;
-      if (path3 === undefined) {
+      const path2 = ast.path ?? ast.query ?? ast.right;
+      if (path2 === undefined) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `(${renderPostgresJsonValue2(base, state, dialect)} @? ${renderJsonOpaquePath2(path3, state, dialect)})`;
+        return `(${renderPostgresJsonValue2(base, state, dialect)} @? ${renderJsonOpaquePath2(path2, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_contains_path(${renderExpression2(base, state, dialect)}, ${dialect.renderLiteral("one", state)}, ${renderJsonOpaquePath2(path3, state, dialect)})`;
+        return `json_contains_path(${renderExpression2(base, state, dialect)}, ${dialect.renderLiteral("one", state)}, ${renderJsonOpaquePath2(path2, state, dialect)})`;
       }
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression4(base)) {
+      if (!isExpression5(base)) {
         return;
       }
-      const path3 = ast.path ?? ast.query ?? ast.right;
-      if (path3 === undefined) {
+      const path2 = ast.path ?? ast.query ?? ast.right;
+      if (path2 === undefined) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `(${renderPostgresJsonValue2(base, state, dialect)} @@ ${renderJsonOpaquePath2(path3, state, dialect)})`;
+        return `(${renderPostgresJsonValue2(base, state, dialect)} @@ ${renderJsonOpaquePath2(path2, state, dialect)})`;
       }
       unsupportedJsonFeature2(dialect, "jsonPathMatch");
     }
   }
   return;
 };
-var selectionProjections2 = (selection) => flattenSelection(selection).map(({ path: path3, alias: alias2 }) => ({
-  path: path3,
+var selectionProjections2 = (selection) => flattenSelection(selection).map(({ path: path2, alias: alias2 }) => ({
+  path: path2,
   alias: alias2
 }));
 var renderMutationAssignment2 = (entry, state, dialect, targetTableName) => {
@@ -8058,9 +8988,9 @@ var validateDistinctOnOrdering = (distinctOn2, orderBy2) => {
   }
   const remainingDistinctKeys = new Set(distinctOn2.map(groupingKeyOfExpression));
   for (const order of orderBy2) {
-    const key3 = groupingKeyOfExpression(order.value);
-    if (remainingDistinctKeys.has(key3)) {
-      remainingDistinctKeys.delete(key3);
+    const key2 = groupingKeyOfExpression(order.value);
+    if (remainingDistinctKeys.has(key2)) {
+      remainingDistinctKeys.delete(key2);
       continue;
     }
     if (remainingDistinctKeys.size > 0) {
@@ -8155,12 +9085,12 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         const columns = insertSource.columns.map((column) => quoteColumn2(column, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
-          const fields2 = table[TypeId6].fields;
+          const fields2 = table[TypeId7].fields;
           const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues2(entry.values, fields2[entry.columnName], state, dialect), state)} as ${renderCastType2(dialect, fields2[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 }, (_, index4) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index4], state, targetSource.source[TypeId7].fields[entry.columnName][TypeId])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -8314,27 +9244,27 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge3 = mergeAst.merge;
-      sql = `merge into ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference2(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 merge2 = mergeAst.merge;
+      sql = `merge into ${renderSourceReference2(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference2(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge2.on, state, dialect)}`;
+      if (merge2.whenMatched) {
+        const matchedKind = merge2.whenMatched.kind === "delete" ? "delete" : "update";
         sql += " when matched";
-        if (merge3.whenMatched.predicate) {
-          sql += ` and ${renderExpression2(merge3.whenMatched.predicate, state, dialect)}`;
+        if (merge2.whenMatched.predicate) {
+          sql += ` and ${renderExpression2(merge2.whenMatched.predicate, state, dialect)}`;
         }
         if (matchedKind === "delete") {
           sql += " then delete";
         } else {
-          const matchedUpdate = merge3.whenMatched;
+          const matchedUpdate = merge2.whenMatched;
           sql += ` then update set ${matchedUpdate.values.map((entry) => `${quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge3.whenNotMatched) {
+      if (merge2.whenNotMatched) {
         sql += " when not matched";
-        if (merge3.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression2(merge3.whenNotMatched.predicate, state, dialect)}`;
+        if (merge2.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression2(merge2.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge3.whenNotMatched.values.map((entry) => quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge3.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge2.whenNotMatched.values.map((entry) => quoteColumn2(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge2.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -8398,7 +9328,7 @@ var renderSourceReference2 = (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 }, (_, index4) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index4]])));
     return renderSelectRows(rows, columnNames);
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
@@ -8448,11 +9378,11 @@ var renderSourceReference2 = (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);
@@ -8559,11 +9489,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions2("contains", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression3(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression3(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} @> ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression3(leftExpression) && isJsonExpression3(rightExpression)) {
         return `json_contains(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -8572,11 +9502,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions2("containedBy", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression3(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression3(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} <@ ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression3(leftExpression) && isJsonExpression3(rightExpression)) {
         return `json_contains(${renderExpression2(rightExpression, state, dialect)}, ${renderExpression2(leftExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -8585,11 +9515,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions2("overlaps", ast.left, ast.right);
       if (dialect.name === "postgres") {
         assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
-        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
-        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
+        const left = isJsonExpression3(leftExpression) ? renderPostgresJsonValue2(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression3(rightExpression) ? renderPostgresJsonValue2(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} && ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression3(leftExpression) && isJsonExpression3(rightExpression)) {
         return `json_overlaps(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -8767,7 +9697,6 @@ var renderSqlitePlan = (plan, options2 = {}) => {
 
 // src/sqlite/executor.ts
 var withTransaction2 = withTransaction;
-var withSavepoint2 = withSavepoint;
 function driver2(dialectOrExecute, maybeExecute) {
   const executeOrHandlers = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute;
   return typeof executeOrHandlers === "function" ? driver("sqlite", executeOrHandlers) : driver("sqlite", executeOrHandlers);
@@ -8789,8 +9718,8 @@ var fromDriver2 = (renderer, sqlDriver, driverMode = "raw", valueMappings) => ({
   },
   stream(plan) {
     const rendered = renderer.render(plan);
-    return Stream2.mapError(Stream2.mapChunksEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
-      try: () => decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+    return Stream2.mapError(Stream2.mapArrayEffect(sqlDriver.stream(rendered), (rows) => Effect2.try({
+      try: () => decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
       catch: (error) => error
     })), (error) => {
       if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
@@ -8817,6 +9746,20 @@ var exports_query_extension = {};
 __export(exports_query_extension, {
   onConflict: () => onConflict
 });
+// src/sqlite/type.ts
+var custom4 = (kind) => ({
+  dialect: "sqlite",
+  kind
+});
+var driverValueMapping3 = (dbType, mapping) => ({
+  ...dbType,
+  driverValueMapping: mapping
+});
+var type2 = {
+  ...pickDatatypeConstructors(sqliteDatatypes, sqliteSpecificDatatypeKeys),
+  custom: custom4,
+  driverValueMapping: driverValueMapping3
+};
 // src/sqlite/renderer.ts
 var exports_renderer2 = {};
 __export(exports_renderer2, {
@@ -8824,26 +9767,28 @@ __export(exports_renderer2, {
   make: () => make5,
   TypeId: () => TypeId10
 });
-import { pipeArguments as pipeArguments7 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments8 } from "effect/Pipeable";
 var RendererProto = {
   pipe() {
-    return pipeArguments7(this, arguments);
+    return pipeArguments8(this, arguments);
   }
 };
-var make5 = (options2 = {}) => {
-  const renderer = makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, options2));
+var makeWithState = (state = {}) => {
+  const renderer = makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, state));
   return Object.assign(Object.create(RendererProto), renderer, {
-    [TypeId5]: {
-      casing: options2.casing
+    [TypeId6]: {
+      casing: state.casing
     },
-    withCasing: (override) => make5({
-      ...options2,
-      casing: merge(options2.casing, override)
+    withCasing: (override) => makeWithState({
+      ...state,
+      casing: merge(state.casing, override)
     })
   });
 };
+var make5 = (options2 = {}) => makeWithState({ valueMappings: options2.valueMappings });
 var sqlite = make5();
 export {
+  type2 as Type,
   exports_renderer2 as Renderer,
   exports_query_extension as Query,
   exports_json as Json,