@velarscript-labs/sqlite 0.2.2 → 0.3.1

package/dist/index.js

@@ -1,3 +1,75 @@
+// velar-standard:velar/text
+var __velarMaxTextCodeUnits = 16 * 1024 * 1024;
+var __velarTextNativeArray = globalThis.Array;
+var __velarTextNativeString = globalThis.String;
+var __velarTextNativeNumber = globalThis.Number;
+var __velarTextNativeMath = globalThis.Math;
+var __velarTextNativeObject = globalThis.Object;
+var __velarTextNativeMap = globalThis.Map;
+var __velarTextNativeTypeError = globalThis.TypeError;
+var __velarTextNativeRangeError = globalThis.RangeError;
+var __velarTextGetOwnPropertyDescriptor = __velarTextNativeObject.getOwnPropertyDescriptor;
+var __velarTextRuntimeGetPrototypeOf = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "getPrototypeOf")?.value;
+var __velarTextReflectApply = __velarTextGetOwnPropertyDescriptor(globalThis.Reflect, "apply")?.value;
+var __velarTextStringPrototype = __velarTextGetOwnPropertyDescriptor(__velarTextNativeString, "prototype")?.value;
+var __velarTextArrayIsArray = __velarTextGetOwnPropertyDescriptor(__velarTextNativeArray, "isArray")?.value;
+var __velarTextNumberIsSafeInteger = __velarTextGetOwnPropertyDescriptor(__velarTextNativeNumber, "isSafeInteger")?.value;
+var __velarTextNumberIsInteger = __velarTextGetOwnPropertyDescriptor(__velarTextNativeNumber, "isInteger")?.value;
+var __velarTextMathFloor = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "floor")?.value;
+var __velarTextMathMax = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "max")?.value;
+var __velarTextMathMin = __velarTextGetOwnPropertyDescriptor(__velarTextNativeMath, "min")?.value;
+var __velarNativeStringIndexOf = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "indexOf")?.value;
+var __velarNativeStringSlice = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "slice")?.value;
+var __velarNativeStringCharCodeAt = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "charCodeAt")?.value;
+var __velarNativeStringTrim = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "trim")?.value;
+var __velarNativeStringUpper = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toUpperCase")?.value;
+var __velarNativeStringLower = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "toLowerCase")?.value;
+var __velarNativeStringSplit = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "split")?.value;
+var __velarNativeStringReplaceAll = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "replaceAll")?.value;
+var __velarNativeStringRepeat = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "repeat")?.value;
+var __velarTextMapPrototype = typeof __velarTextNativeMap === "function" ? __velarTextGetOwnPropertyDescriptor(__velarTextNativeMap, "prototype")?.value : null;
+var __velarTextMapGet = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "get")?.value : null;
+var __velarTextMapSet = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "set")?.value : null;
+var __velarTextMapClear = __velarTextMapPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextMapPrototype, "clear")?.value : null;
+var __velarTextSurrogatePattern = /[\u{10000}-\u{10FFFF}\uD800-\uDFFF]/u;
+var __velarTextRegExpPrototype = typeof __velarTextRuntimeGetPrototypeOf === "function" ? __velarTextRuntimeGetPrototypeOf(__velarTextSurrogatePattern) : null;
+var __velarTextSurrogateExec = __velarTextRegExpPrototype ? __velarTextGetOwnPropertyDescriptor(__velarTextRegExpPrototype, "exec")?.value : null;
+function __velarTextCall(operation, receiver, arguments_) {
+  if (typeof operation !== "function" || typeof __velarTextReflectApply !== "function") throw new __velarTextNativeTypeError("The JavaScript text runtime is unavailable");
+  return __velarTextReflectApply(operation, receiver, arguments_);
+}
+var __velarTextMeasureCacheUnits = 8 * 1024 * 1024;
+var __velarTextMeasureCache = typeof __velarTextNativeMap === "function" && typeof __velarTextMapGet === "function" && typeof __velarTextMapSet === "function" && typeof __velarTextMapClear === "function" ? new __velarTextNativeMap() : null;
+var __velarUtf8CharCodeAt = Object.getOwnPropertyDescriptor(String.prototype, "charCodeAt")?.value;
+var __velarUtf8ReflectApply = Object.getOwnPropertyDescriptor(Reflect, "apply")?.value;
+var __velarTextGetOwnPropertyNames = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "getOwnPropertyNames")?.value;
+var __velarTextGetOwnPropertySymbols = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "getOwnPropertySymbols")?.value;
+var __velarTextGetPrototypeOf = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "getPrototypeOf")?.value;
+var __velarTextObjectPrototype = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "prototype")?.value;
+var __velarTextObjectCreate = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "create")?.value;
+var __velarTextObjectFreeze = __velarTextGetOwnPropertyDescriptor(__velarTextNativeObject, "freeze")?.value;
+var __velarTextArrayPrototype = __velarTextGetOwnPropertyDescriptor(__velarTextNativeArray, "prototype")?.value;
+var __velarTextArrayJoin = __velarTextGetOwnPropertyDescriptor(__velarTextArrayPrototype, "join")?.value;
+var __velarTextStringTrimStart = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "trimStart")?.value;
+var __velarTextStringTrimEnd = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "trimEnd")?.value;
+var __velarTextStringNormalize = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "normalize")?.value;
+var __velarTextNativeDate = globalThis.Date;
+var __velarTextDateNow = __velarTextGetOwnPropertyDescriptor(__velarTextNativeDate, "now")?.value;
+var nativeRegExpPrototype = __velarTextGetPrototypeOf(/(?:)/u);
+var NativeRegExp = __velarTextGetOwnPropertyDescriptor(nativeRegExpPrototype, "constructor")?.value;
+var nativeRegExpExec = __velarTextGetOwnPropertyDescriptor(nativeRegExpPrototype, "exec")?.value;
+var __velarTextStringCodePointAt = __velarTextGetOwnPropertyDescriptor(__velarTextStringPrototype, "codePointAt")?.value;
+var __velarTextStringFromCodePoint = __velarTextGetOwnPropertyDescriptor(__velarTextNativeString, "fromCodePoint")?.value;
+var __velarTextLatinMarks = new RegExp("(?<=\\p{Script=Latin})\\p{M}+", "gu");
+var __velarTextBaselessMarks = new RegExp("(?<![\\p{L}\\p{N}\\p{M}])\\p{M}+", "gu");
+function fromCodePoint(value) {
+  if (!__velarTextCall(__velarTextNumberIsSafeInteger, __velarTextNativeNumber, [value]) || value < 0 || value > 1114111) {
+    throw new __velarTextNativeRangeError("fromCodePoint requires a code point from 0 through 1114111");
+  }
+  if (value >= 55296 && value <= 57343) throw new __velarTextNativeRangeError("fromCodePoint refuses surrogate halves; they are not characters on their own");
+  return __velarTextCall(__velarTextStringFromCodePoint, __velarTextNativeString, [value]);
+}
+
 // velar-standard:velar/compiler-runtime-reactive-v1
 var __velarReactiveStructureKey = null;
 function __velarReactiveRaw(value) {
@@ -16,6 +88,210 @@ function __velarReactiveCollectionLink() {
 function __velarReactiveCollectionTrigger() {
 }
 
+// velar-standard:velar/compiler-runtime-primitives-v1
+var __velarMaxTextCodeUnits2 = 16 * 1024 * 1024;
+var __velarTextNativeArray2 = globalThis.Array;
+var __velarTextNativeString2 = globalThis.String;
+var __velarTextNativeNumber2 = globalThis.Number;
+var __velarTextNativeMath2 = globalThis.Math;
+var __velarTextNativeObject2 = globalThis.Object;
+var __velarTextNativeMap2 = globalThis.Map;
+var __velarTextNativeTypeError2 = globalThis.TypeError;
+var __velarTextNativeRangeError2 = globalThis.RangeError;
+var __velarTextGetOwnPropertyDescriptor2 = __velarTextNativeObject2.getOwnPropertyDescriptor;
+var __velarTextRuntimeGetPrototypeOf2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeObject2, "getPrototypeOf")?.value;
+var __velarTextReflectApply2 = __velarTextGetOwnPropertyDescriptor2(globalThis.Reflect, "apply")?.value;
+var __velarTextStringPrototype2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeString2, "prototype")?.value;
+var __velarTextArrayIsArray2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeArray2, "isArray")?.value;
+var __velarTextNumberIsSafeInteger2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeNumber2, "isSafeInteger")?.value;
+var __velarTextNumberIsInteger2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeNumber2, "isInteger")?.value;
+var __velarTextMathFloor2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeMath2, "floor")?.value;
+var __velarTextMathMax2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeMath2, "max")?.value;
+var __velarTextMathMin2 = __velarTextGetOwnPropertyDescriptor2(__velarTextNativeMath2, "min")?.value;
+var __velarNativeStringIndexOf2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "indexOf")?.value;
+var __velarNativeStringSlice2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "slice")?.value;
+var __velarNativeStringCharCodeAt2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "charCodeAt")?.value;
+var __velarNativeStringTrim2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "trim")?.value;
+var __velarNativeStringUpper2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "toUpperCase")?.value;
+var __velarNativeStringLower2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "toLowerCase")?.value;
+var __velarNativeStringSplit2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "split")?.value;
+var __velarNativeStringReplaceAll2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "replaceAll")?.value;
+var __velarNativeStringRepeat2 = __velarTextGetOwnPropertyDescriptor2(__velarTextStringPrototype2, "repeat")?.value;
+var __velarTextMapPrototype2 = typeof __velarTextNativeMap2 === "function" ? __velarTextGetOwnPropertyDescriptor2(__velarTextNativeMap2, "prototype")?.value : null;
+var __velarTextMapGet2 = __velarTextMapPrototype2 ? __velarTextGetOwnPropertyDescriptor2(__velarTextMapPrototype2, "get")?.value : null;
+var __velarTextMapSet2 = __velarTextMapPrototype2 ? __velarTextGetOwnPropertyDescriptor2(__velarTextMapPrototype2, "set")?.value : null;
+var __velarTextMapClear2 = __velarTextMapPrototype2 ? __velarTextGetOwnPropertyDescriptor2(__velarTextMapPrototype2, "clear")?.value : null;
+var __velarTextSurrogatePattern2 = /[\u{10000}-\u{10FFFF}\uD800-\uDFFF]/u;
+var __velarTextRegExpPrototype2 = typeof __velarTextRuntimeGetPrototypeOf2 === "function" ? __velarTextRuntimeGetPrototypeOf2(__velarTextSurrogatePattern2) : null;
+var __velarTextSurrogateExec2 = __velarTextRegExpPrototype2 ? __velarTextGetOwnPropertyDescriptor2(__velarTextRegExpPrototype2, "exec")?.value : null;
+function __velarTextCall2(operation, receiver, arguments_) {
+  if (typeof operation !== "function" || typeof __velarTextReflectApply2 !== "function") throw new __velarTextNativeTypeError2("The JavaScript text runtime is unavailable");
+  return __velarTextReflectApply2(operation, receiver, arguments_);
+}
+function __velarTextValue(value) {
+  if (typeof value !== "string") throw new __velarTextNativeTypeError2("String methods require a string receiver");
+  if (value.length > __velarMaxTextCodeUnits2) throw new __velarTextNativeRangeError2("Strings cannot exceed 16 MiB");
+  return value;
+}
+function __velarTextArgument(value, name) {
+  if (typeof value !== "string") throw new __velarTextNativeTypeError2(name + " must be a string");
+  if (value.length > __velarMaxTextCodeUnits2) throw new __velarTextNativeRangeError2(name + " cannot exceed 16 MiB");
+  return value;
+}
+function __velarTextNextCodePointOffset(value, offset) {
+  const first = __velarTextCall2(__velarNativeStringCharCodeAt2, value, [offset]);
+  if (first < 55296 || first > 56319 || offset + 1 >= value.length) return offset + 1;
+  const second = __velarTextCall2(__velarNativeStringCharCodeAt2, value, [offset + 1]);
+  return second >= 56320 && second <= 57343 ? offset + 2 : offset + 1;
+}
+var __velarTextCheckpointStride = 64;
+var __velarTextMeasureMinimumUnits = 64;
+var __velarTextMeasureCacheEntries = 512;
+var __velarTextMeasureCacheUnits2 = 8 * 1024 * 1024;
+var __velarTextMeasureCache2 = typeof __velarTextNativeMap2 === "function" && typeof __velarTextMapGet2 === "function" && typeof __velarTextMapSet2 === "function" && typeof __velarTextMapClear2 === "function" ? new __velarTextNativeMap2() : null;
+var __velarTextMeasureCacheCount = 0;
+var __velarTextMeasureCacheHeld = 0;
+function __velarTextMeasureText(value) {
+  if (__velarTextCall2(__velarTextSurrogateExec2, __velarTextSurrogatePattern2, [value]) === null) {
+    return { length: value.length, dense: true, checkpoints: null };
+  }
+  const checkpoints = new __velarTextNativeArray2();
+  let length = 0, offset = 0;
+  while (offset < value.length) {
+    if (length % __velarTextCheckpointStride === 0) checkpoints[length / __velarTextCheckpointStride] = offset;
+    offset = __velarTextNextCodePointOffset(value, offset);
+    length += 1;
+  }
+  return { length, dense: length === value.length, checkpoints };
+}
+function __velarTextMeasure(value) {
+  if (__velarTextMeasureCache2 === null || value.length < __velarTextMeasureMinimumUnits) return __velarTextMeasureText(value);
+  const cached = __velarTextCall2(__velarTextMapGet2, __velarTextMeasureCache2, [value]);
+  if (cached !== void 0) return cached;
+  const measured = __velarTextMeasureText(value);
+  if (__velarTextMeasureCacheCount >= __velarTextMeasureCacheEntries || __velarTextMeasureCacheCount > 0 && __velarTextMeasureCacheHeld + value.length > __velarTextMeasureCacheUnits2) {
+    __velarTextCall2(__velarTextMapClear2, __velarTextMeasureCache2, []);
+    __velarTextMeasureCacheCount = 0;
+    __velarTextMeasureCacheHeld = 0;
+  }
+  __velarTextCall2(__velarTextMapSet2, __velarTextMeasureCache2, [value, measured]);
+  __velarTextMeasureCacheCount += 1;
+  __velarTextMeasureCacheHeld += value.length;
+  return measured;
+}
+function __velarTextCodePointLength(value) {
+  return __velarTextMeasure(value).length;
+}
+function __velarTextIsBoundary(value, offset) {
+  if (offset <= 0 || offset >= value.length) return true;
+  const lead = __velarTextCall2(__velarNativeStringCharCodeAt2, value, [offset - 1]);
+  if (lead < 55296 || lead > 56319) return true;
+  const trail = __velarTextCall2(__velarNativeStringCharCodeAt2, value, [offset]);
+  return trail < 56320 || trail > 57343;
+}
+function __velarTextNeedsBoundaryCheck(search) {
+  const first = __velarTextCall2(__velarNativeStringCharCodeAt2, search, [0]);
+  if (first >= 56320 && first <= 57343) return true;
+  const last = __velarTextCall2(__velarNativeStringCharCodeAt2, search, [search.length - 1]);
+  return last >= 55296 && last <= 56319;
+}
+function __velarTextBoundedIndexOf(value, search, cursor) {
+  if (!__velarTextNeedsBoundaryCheck(search)) return __velarTextCall2(__velarNativeStringIndexOf2, value, [search, cursor]);
+  while (cursor <= value.length) {
+    const found = __velarTextCall2(__velarNativeStringIndexOf2, value, [search, cursor]);
+    if (found < 0) return -1;
+    if (__velarTextIsBoundary(value, found) && __velarTextIsBoundary(value, found + search.length)) return found;
+    cursor = found + 1;
+  }
+  return -1;
+}
+function __velarTextReplacementOutputUnits(value, search, replacement, all) {
+  let matches = 0;
+  if (search === "") matches = all ? __velarTextCodePointLength(value) + 1 : 1;
+  else {
+    let cursor = 0;
+    while (true) {
+      const index = __velarTextBoundedIndexOf(value, search, cursor);
+      if (index < 0) break;
+      matches += 1;
+      if (!all) break;
+      cursor = index + search.length;
+    }
+  }
+  if (replacement.length <= search.length || matches === 0) return value.length;
+  const growth = replacement.length - search.length;
+  if (matches > __velarTextCall2(__velarTextMathFloor2, __velarTextNativeMath2, [(__velarMaxTextCodeUnits2 - value.length) / growth])) return __velarMaxTextCodeUnits2 + 1;
+  return value.length + matches * growth;
+}
+function __velarStringSize(value) {
+  return __velarTextCodePointLength(__velarTextValue(value));
+}
+function __velarStringIsBlank(value) {
+  return __velarTextCall2(__velarNativeStringTrim2, __velarTextValue(value), []) === "";
+}
+function __velarStringHas(value, text) {
+  value = __velarTextValue(value);
+  text = __velarTextArgument(text, "String.has text");
+  return text === "" || __velarTextBoundedIndexOf(value, text, 0) >= 0;
+}
+function __velarStringReplaceAll(value, from, to) {
+  value = __velarTextValue(value);
+  from = __velarTextArgument(from, "String.replaceAll from");
+  to = __velarTextArgument(to, "String.replaceAll to");
+  if (__velarTextReplacementOutputUnits(value, from, to, true) > __velarMaxTextCodeUnits2) throw new __velarTextNativeRangeError2("String.replaceAll output cannot exceed 16 MiB");
+  if (from === "") {
+    let output2 = to;
+    let offset = 0;
+    while (offset < value.length) {
+      const next = __velarTextNextCodePointOffset(value, offset);
+      output2 += __velarTextCall2(__velarNativeStringSlice2, value, [offset, next]) + to;
+      offset = next;
+    }
+    return output2;
+  }
+  if (!__velarTextNeedsBoundaryCheck(from)) return __velarTextCall2(__velarNativeStringReplaceAll2, value, [from, () => to]);
+  let output = "";
+  let cursor = 0;
+  while (true) {
+    const found = __velarTextBoundedIndexOf(value, from, cursor);
+    if (found < 0) break;
+    output += __velarTextCall2(__velarNativeStringSlice2, value, [cursor, found]) + to;
+    cursor = found + from.length;
+  }
+  return output + __velarTextCall2(__velarNativeStringSlice2, value, [cursor]);
+}
+var __velarNumberNativeMath = globalThis.Math;
+var __velarNumberNativeNumber = globalThis.Number;
+var __velarNumberNativeObject = globalThis.Object;
+var __velarNumberNativeTypeError = globalThis.TypeError;
+var __velarNumberNativeRangeError = globalThis.RangeError;
+var __velarNumberGetOwnPropertyDescriptor = __velarNumberNativeObject.getOwnPropertyDescriptor;
+var __velarNumberReflectApply = __velarNumberGetOwnPropertyDescriptor(globalThis.Reflect, "apply")?.value;
+var __velarNumberPrototype = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeNumber, "prototype")?.value;
+var __velarNumberMathAbs = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeMath, "abs")?.value;
+var __velarNumberMathRound = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeMath, "round")?.value;
+var __velarNumberMathFloor = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeMath, "floor")?.value;
+var __velarNumberMathCeil = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeMath, "ceil")?.value;
+var __velarNumberIsSafeInteger = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeNumber, "isSafeInteger")?.value;
+var __velarNumberNativeIsInteger = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeNumber, "isInteger")?.value;
+var __velarNumberNativeIsNaN = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeNumber, "isNaN")?.value;
+var __velarNumberNativeIsFinite = __velarNumberGetOwnPropertyDescriptor(__velarNumberNativeNumber, "isFinite")?.value;
+var __velarNativeNumberToFixed = __velarNumberGetOwnPropertyDescriptor(__velarNumberPrototype, "toFixed")?.value;
+function __velarNumberCall(operation, receiver, arguments_) {
+  if (typeof operation !== "function" || typeof __velarNumberReflectApply !== "function") throw new __velarNumberNativeTypeError("The JavaScript Number runtime is unavailable");
+  return __velarNumberReflectApply(operation, receiver, arguments_);
+}
+function __velarNumberValue(value) {
+  if (typeof value !== "number") throw new __velarNumberNativeTypeError("Number methods require a number receiver");
+  return value;
+}
+function __velarNumberIsInteger(value) {
+  return __velarNumberCall(__velarNumberNativeIsInteger, __velarNumberNativeNumber, [__velarNumberValue(value)]);
+}
+function __velarNumberIsFinite(value) {
+  return __velarNumberCall(__velarNumberNativeIsFinite, __velarNumberNativeNumber, [__velarNumberValue(value)]);
+}
+
 // velar-standard:velar/compiler-runtime-class-fields-v1
 var __velarClassNativeObject = globalThis.Object;
 var __velarClassNativeReflect = globalThis.Reflect;
@@ -779,7 +1055,7 @@ function __velarListMap(value, transform) {
 }
 
 // src/src/index.vel
-import { DatabaseExecutor } from "@velarscript-labs/database";
+import { DatabaseExecutor, DatabaseStatement, trustedSql } from "@velarscript-labs/database";
 
 // velar-embedded:src/index.2ibbmz.embedded-1.js
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -818,20 +1094,30 @@ function integer(value, fallback, minimum, maximum, label) {
 }
 function checkedOptions(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("SQLite options must be a record");
-  const allowed = /* @__PURE__ */ new Set(["busyTimeoutMilliseconds", "queueCapacity", "maxRows", "maxResultBytes"]);
+  const allowed = /* @__PURE__ */ new Set(["busyTimeoutMilliseconds", "queueCapacity", "maxRows", "maxResultBytes", "statementCacheCapacity", "journalMode", "readOnly"]);
   for (const key of Object.keys(value)) if (!allowed.has(key)) throw new TypeError("Unknown SQLite option " + key);
+  const journalModes = /* @__PURE__ */ new Set(["delete", "truncate", "persist", "memory", "wal", "off"]);
+  const journalMode = value.journalMode == null ? null : value.journalMode;
+  if (journalMode !== null && (typeof journalMode !== "string" || !journalModes.has(journalMode))) throw new TypeError("SQLite journalMode must name a supported mode");
+  if (value.readOnly != null && typeof value.readOnly !== "boolean") throw new TypeError("SQLite readOnly must be bool");
+  if (value.readOnly === true && journalMode !== null) throw new TypeError("SQLite readOnly connections cannot change journalMode");
   return {
     busyTimeoutMilliseconds: integer(value.busyTimeoutMilliseconds, 2e3, 1, 6e4, "SQLite busy timeout"),
     queueCapacity: integer(value.queueCapacity, 64, 1, 1024, "SQLite queue capacity"),
     maxRows: integer(value.maxRows, 1e4, 1, 1e6, "SQLite row limit"),
-    maxResultBytes: integer(value.maxResultBytes, 64 * 1024 * 1024, 1, 128 * 1024 * 1024, "SQLite result byte limit")
+    maxResultBytes: integer(value.maxResultBytes, 64 * 1024 * 1024, 1, 128 * 1024 * 1024, "SQLite result byte limit"),
+    statementCacheCapacity: integer(value.statementCacheCapacity, 128, 1, 1024, "SQLite statement cache capacity"),
+    journalMode,
+    readOnly: value.readOnly === true
   };
 }
 function workerMain() {
   const { Buffer } = (0, globalThis.require)("node:buffer");
   const { parentPort, workerData } = (0, globalThis.require)("node:worker_threads");
-  const { DatabaseSync } = (0, globalThis.require)("node:sqlite");
+  const { DatabaseSync, constants } = (0, globalThis.require)("node:sqlite");
+  const { parseStmt } = (0, globalThis.require)("sqlite3-parser");
   let database = null;
+  let statements = null;
   let closed = false;
   function failure(message, code, operation, retryable = false) {
     const error = new Error(message);
@@ -852,12 +1138,6 @@ function workerMain() {
       retryable: error && error.retryable === true || upper.includes("BUSY") || upper.includes("LOCKED")
     };
   }
-  function sqlText(value, operation) {
-    if (typeof value !== "string" || value.length === 0 || value.length > 1024 * 1024 || value.includes("\0")) {
-      throw failure("SQLite SQL must be non-empty text no longer than 1 MiB", "SQLITE_INPUT", operation);
-    }
-    return value;
-  }
   function parameter(value, budget) {
     if (value === null) return null;
     if (typeof value === "boolean") return value ? 1 : 0;
@@ -884,6 +1164,28 @@ function workerMain() {
     if (budget.value > workerData.maxResultBytes) throw failure("SQLite parameters exceed the connection byte limit", "SQLITE_INPUT", "params");
     return output;
   }
+  function statementParts(rawFragments, rawParameters, operation) {
+    if (!Array.isArray(rawFragments) || rawFragments.length !== rawParameters.length + 1 || rawFragments.length > 1e3) {
+      throw failure("SQLite statements require exactly one more SQL fragment than bound parameters", "SQLITE_INPUT", operation);
+    }
+    let sourceBytes = 0;
+    const fragments = rawFragments.map((fragment) => {
+      if (typeof fragment !== "string" || fragment.includes("\0") || fragment.includes("?")) {
+        throw failure("SQLite SQL fragments must be text without NUL or raw parameter placeholders", "SQLITE_INPUT", operation);
+      }
+      sourceBytes += Buffer.byteLength(fragment, "utf8");
+      return fragment;
+    });
+    if (sourceBytes === 0 || sourceBytes > 1024 * 1024) throw failure("SQLite SQL must be non-empty text no longer than 1 MiB", "SQLITE_INPUT", operation);
+    const bound = parameters(rawParameters);
+    const source = fragments.join("?");
+    const parsed = parseStmt(source);
+    if (parsed.status !== "ok") {
+      const message = parsed.errors.length === 0 ? "invalid statement" : parsed.errors[0].message;
+      throw failure("SQLite requires exactly one valid statement: " + message, "SQLITE_INPUT", operation);
+    }
+    return { fragments, bound };
+  }
   function count(value, label) {
     const number = typeof value === "bigint" ? Number(value) : value;
     if (!Number.isSafeInteger(number) || number < 0) throw failure(label + " is outside VelarScript's safe integer range", "SQLITE_INTEGER_RANGE", "result");
@@ -922,27 +1224,22 @@ function workerMain() {
     }
     return output;
   }
-  function statement(sql, operation) {
-    const prepared = database.prepare(sqlText(sql, operation));
-    if (typeof prepared.setReadBigInts === "function") prepared.setReadBigInts(true);
-    return prepared;
-  }
   function execute(message) {
-    const prepared = statement(message.sql, "execute");
-    const result = prepared.run(...parameters(message.params));
+    const statement = statementParts(message.fragments, message.params, "execute");
+    const result = statements.run(statement.fragments, ...statement.bound);
     return count(result.changes, "SQLite affected row count");
   }
   function one(message) {
-    const prepared = statement(message.sql, "one");
-    const row = prepared.get(...parameters(message.params));
+    const statement = statementParts(message.fragments, message.params, "one");
+    const row = statements.get(statement.fragments, ...statement.bound);
     if (row === void 0) return null;
     return resultRow(row, { value: 0 });
   }
   function all(message) {
-    const prepared = statement(message.sql, "all");
+    const statement = statementParts(message.fragments, message.params, "all");
     const rows = [];
     const budget = { value: 0 };
-    for (const row of prepared.iterate(...parameters(message.params))) {
+    for (const row of statements.iterate(statement.fragments, ...statement.bound)) {
       if (rows.length >= workerData.maxRows) throw failure("SQLite result exceeds the connection row limit", "SQLITE_ROW_LIMIT", "all");
       rows.push(resultRow(row, budget));
     }
@@ -979,8 +1276,39 @@ function workerMain() {
     throw failure("Unknown SQLite operation", "SQLITE_PROTOCOL", String(message.operation));
   }
   try {
-    database = new DatabaseSync(workerData.path, { timeout: workerData.busyTimeoutMilliseconds });
-    database.exec("PRAGMA foreign_keys = ON");
+    database = new DatabaseSync(workerData.path, {
+      timeout: workerData.busyTimeoutMilliseconds,
+      readOnly: workerData.readOnly,
+      enableForeignKeyConstraints: true,
+      enableDoubleQuotedStringLiterals: false,
+      allowExtension: false,
+      readBigInts: true,
+      allowBareNamedParameters: false,
+      allowUnknownNamedParameters: false,
+      defensive: true,
+      limits: {
+        length: workerData.maxResultBytes,
+        sqlLength: 1024 * 1024,
+        column: 2e3,
+        exprDepth: 1e3,
+        compoundSelect: 500,
+        vdbeOp: 25e4,
+        functionArg: 1e3,
+        attach: 0,
+        likePatternLength: 5e4,
+        variableNumber: 999,
+        triggerDepth: 100
+      }
+    });
+    database.enableDefensive(true);
+    database.enableLoadExtension(false);
+    database.setAuthorizer((actionCode, arg1, arg2) => {
+      if (actionCode === constants.SQLITE_ATTACH || actionCode === constants.SQLITE_DETACH) return constants.SQLITE_DENY;
+      if (actionCode === constants.SQLITE_FUNCTION && typeof arg2 === "string" && arg2.toLowerCase() === "load_extension") return constants.SQLITE_DENY;
+      return constants.SQLITE_OK;
+    });
+    statements = database.createTagStore(workerData.statementCacheCapacity);
+    if (workerData.journalMode !== null) database.exec("PRAGMA journal_mode = " + workerData.journalMode.toUpperCase());
     parentPort.postMessage({ kind: "ready" });
   } catch (error) {
     parentPort.postMessage({ kind: "ready", error: errorData(error, "open") });
@@ -1009,13 +1337,13 @@ function failPending(state, error) {
   for (const pending of state.pending.values()) pending.reject(error);
   state.pending.clear();
 }
-function request(state, operation, sql = "", params = []) {
+function request(state, operation, fragments = [""], params = []) {
   if (state.closed) return Promise.reject(new NativeSqliteError("SQLite connection is closed", "SQLITE_CLOSED", operation));
   const id = state.nextId++;
   return new Promise((resolve, reject) => {
     state.pending.set(id, { resolve, reject });
     try {
-      state.worker.postMessage({ id, operation, sql, params });
+      state.worker.postMessage({ id, operation, fragments, params });
     } catch (error) {
       state.pending.delete(id);
       reject(error);
@@ -1032,11 +1360,11 @@ function transactionStateOf(transaction) {
   if (!state || !state.active) throw new NativeSqliteConcurrencyError("SQLite transaction is no longer active");
   return state;
 }
-function transactionRequest(transaction, operation, sql = "", params = []) {
+function transactionRequest(transaction, operation, fragments = [""], params = []) {
   const state = transactionStateOf(transaction);
   if (state.busy) return Promise.reject(new NativeSqliteConcurrencyError("SQLite transaction operations must be awaited one at a time"));
   state.busy = true;
-  return request(state.connection, operation, sql, params).finally(() => {
+  return request(state.connection, operation, fragments, params).finally(() => {
     state.busy = false;
   });
 }
@@ -1056,14 +1384,14 @@ var NativeSqliteTransaction = class {
     if (token !== TOKEN) throw new TypeError("SQLite transactions are created by connection.transaction");
     transactionStates.set(this, state);
   }
-  execute(sql, params = []) {
-    return transactionRequest(this, "execute", sql, params);
+  execute(fragments, params = []) {
+    return transactionRequest(this, "execute", fragments, params);
   }
-  one(sql, params = []) {
-    return transactionRequest(this, "one", sql, params);
+  one(fragments, params = []) {
+    return transactionRequest(this, "one", fragments, params);
   }
-  all(sql, params = []) {
-    return transactionRequest(this, "all", sql, params);
+  all(fragments, params = []) {
+    return transactionRequest(this, "all", fragments, params);
   }
 };
 var NativeSqliteConnection = class {
@@ -1071,17 +1399,17 @@ var NativeSqliteConnection = class {
     if (token !== TOKEN) throw new TypeError("Use openSqlite to create a SQLite connection");
     connectionStates.set(this, state);
   }
-  execute(sql, params = []) {
+  execute(fragments, params = []) {
     const state = stateOf(this);
-    return enqueue(state, () => request(state, "execute", sql, params));
+    return enqueue(state, () => request(state, "execute", fragments, params));
   }
-  one(sql, params = []) {
+  one(fragments, params = []) {
     const state = stateOf(this);
-    return enqueue(state, () => request(state, "one", sql, params));
+    return enqueue(state, () => request(state, "one", fragments, params));
   }
-  all(sql, params = []) {
+  all(fragments, params = []) {
     const state = stateOf(this);
-    return enqueue(state, () => request(state, "all", sql, params));
+    return enqueue(state, () => request(state, "all", fragments, params));
   }
   transaction(operation) {
     if (typeof operation !== "function") return Promise.reject(new TypeError("SQLite transaction requires an async operation"));
@@ -1186,6 +1514,29 @@ async function openNativeSqlite(path, options = {}) {
 }
 
 // src/src/index.vel
+var SqliteJournalMode = __velarRegisterRuntimeType(__velarValidationFreeze({
+  delete: "delete",
+  truncate: "truncate",
+  persist: "persist",
+  memory: "memory",
+  wal: "wal",
+  off: "off",
+  is(value) {
+    return value === "delete" || value === "truncate" || value === "persist" || value === "memory" || value === "wal" || value === "off";
+  },
+  parse(value) {
+    if (!SqliteJournalMode.is(value)) {
+      throw new __VelarValidationError("Value does not match SqliteJournalMode", { path: "SqliteJournalMode" });
+    }
+    return value;
+  },
+  copy(value) {
+    return value;
+  },
+  values() {
+    return ["delete", "truncate", "persist", "memory", "wal", "off"];
+  }
+}));
 function __velarTypeExplain_SqliteOptions(value) {
   if (value === null || typeof value !== "object" || __velarValidationIsArray(value) || !__velarValidationIsPlainObject(value)) {
     return { path: "SqliteOptions", field: null, reason: "the value is not a record" };
@@ -1214,6 +1565,24 @@ function __velarTypeExplain_SqliteOptions(value) {
       return { path: "SqliteOptions.maxResultBytes", field: "maxResultBytes", reason: "field 'maxResultBytes' does not match number?" };
     }
   }
+  {
+    const __velarExplainField = __velarValidationOwnDescriptor(value, "statementCacheCapacity");
+    if (__velarExplainField !== void 0 && !(__velarExplainField.enumerable && "value" in __velarExplainField && (__velarExplainField.value == null || typeof __velarExplainField.value === "number"))) {
+      return { path: "SqliteOptions.statementCacheCapacity", field: "statementCacheCapacity", reason: "field 'statementCacheCapacity' does not match number?" };
+    }
+  }
+  {
+    const __velarExplainField = __velarValidationOwnDescriptor(value, "journalMode");
+    if (__velarExplainField !== void 0 && !(__velarExplainField.enumerable && "value" in __velarExplainField && (__velarExplainField.value == null || SqliteJournalMode.is(__velarExplainField.value)))) {
+      return { path: "SqliteOptions.journalMode", field: "journalMode", reason: "field 'journalMode' does not match SqliteJournalMode?" };
+    }
+  }
+  {
+    const __velarExplainField = __velarValidationOwnDescriptor(value, "readOnly");
+    if (__velarExplainField !== void 0 && !(__velarExplainField.enumerable && "value" in __velarExplainField && (__velarExplainField.value == null || typeof __velarExplainField.value === "boolean"))) {
+      return { path: "SqliteOptions.readOnly", field: "readOnly", reason: "field 'readOnly' does not match bool?" };
+    }
+  }
   return { path: "SqliteOptions", field: null, reason: null };
 }
 function __velarTypeCheck_SqliteOptions(value) {
@@ -1222,7 +1591,10 @@ function __velarTypeCheck_SqliteOptions(value) {
   const __velarField1 = __velarValidationOwnDescriptor(value, "queueCapacity");
   const __velarField2 = __velarValidationOwnDescriptor(value, "maxRows");
   const __velarField3 = __velarValidationOwnDescriptor(value, "maxResultBytes");
-  return !!((__velarField0 === void 0 || __velarField0?.enumerable && "value" in __velarField0 && (__velarField0.value == null || typeof __velarField0.value === "number")) && (__velarField1 === void 0 || __velarField1?.enumerable && "value" in __velarField1 && (__velarField1.value == null || typeof __velarField1.value === "number")) && (__velarField2 === void 0 || __velarField2?.enumerable && "value" in __velarField2 && (__velarField2.value == null || typeof __velarField2.value === "number")) && (__velarField3 === void 0 || __velarField3?.enumerable && "value" in __velarField3 && (__velarField3.value == null || typeof __velarField3.value === "number")));
+  const __velarField4 = __velarValidationOwnDescriptor(value, "statementCacheCapacity");
+  const __velarField5 = __velarValidationOwnDescriptor(value, "journalMode");
+  const __velarField6 = __velarValidationOwnDescriptor(value, "readOnly");
+  return !!((__velarField0 === void 0 || __velarField0?.enumerable && "value" in __velarField0 && (__velarField0.value == null || typeof __velarField0.value === "number")) && (__velarField1 === void 0 || __velarField1?.enumerable && "value" in __velarField1 && (__velarField1.value == null || typeof __velarField1.value === "number")) && (__velarField2 === void 0 || __velarField2?.enumerable && "value" in __velarField2 && (__velarField2.value == null || typeof __velarField2.value === "number")) && (__velarField3 === void 0 || __velarField3?.enumerable && "value" in __velarField3 && (__velarField3.value == null || typeof __velarField3.value === "number")) && (__velarField4 === void 0 || __velarField4?.enumerable && "value" in __velarField4 && (__velarField4.value == null || typeof __velarField4.value === "number")) && (__velarField5 === void 0 || __velarField5?.enumerable && "value" in __velarField5 && (__velarField5.value == null || SqliteJournalMode.is(__velarField5.value))) && (__velarField6 === void 0 || __velarField6?.enumerable && "value" in __velarField6 && (__velarField6.value == null || typeof __velarField6.value === "boolean")));
 }
 function __velarTypeCopy_SqliteOptions(value, __state, __velarCopyPlan) {
   const __velarCopySeen = __state.copy.seen(__state, value, __velarCopyPlan);
@@ -1244,6 +1616,18 @@ function __velarTypeCopy_SqliteOptions(value, __state, __velarCopyPlan) {
     const __velarCopyField = __velarValidationOwnDescriptor(value, "maxResultBytes");
     if (__velarCopyField !== void 0) __state.copy.field(__velarCopy, "maxResultBytes", __velarCopyField.value);
   }
+  {
+    const __velarCopyField = __velarValidationOwnDescriptor(value, "statementCacheCapacity");
+    if (__velarCopyField !== void 0) __state.copy.field(__velarCopy, "statementCacheCapacity", __velarCopyField.value);
+  }
+  {
+    const __velarCopyField = __velarValidationOwnDescriptor(value, "journalMode");
+    if (__velarCopyField !== void 0) __state.copy.field(__velarCopy, "journalMode", __velarCopyField.value);
+  }
+  {
+    const __velarCopyField = __velarValidationOwnDescriptor(value, "readOnly");
+    if (__velarCopyField !== void 0) __state.copy.field(__velarCopy, "readOnly", __velarCopyField.value);
+  }
   return __velarCopy;
 }
 var SqliteOptions = __velarRegisterRuntimeType(__velarValidationFreeze({
@@ -1287,67 +1671,98 @@ var SqliteConcurrencyError = class extends SqliteError {
 };
 function sqliteFailure(error) {
   if (error instanceof NativeSqliteBackpressureError) {
-    return new SqliteBackpressureError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteBackpressureError), "NativeSqliteBackpressureError", "error", 20523))(error).message);
+    return new SqliteBackpressureError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteBackpressureError), "NativeSqliteBackpressureError", "error", 24269))(error).message);
   }
   if (error instanceof NativeSqliteConcurrencyError) {
-    return new SqliteConcurrencyError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteConcurrencyError), "NativeSqliteConcurrencyError", "error", 20622))(error).message);
+    return new SqliteConcurrencyError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteConcurrencyError), "NativeSqliteConcurrencyError", "error", 24368))(error).message);
   }
   if (error instanceof NativeSqliteError) {
-    return new SqliteError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 20699))(error).message, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 20714))(error).sqliteCode ?? null, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 20732))(error).operation, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 20749))(error).retryable);
+    return new SqliteError(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24445))(error).message, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24460))(error).sqliteCode ?? null, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24478))(error).operation, ((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24495))(error).retryable);
   }
   return new SqliteError(error.message);
 }
+function sqliteLiteral(value) {
+  if ((value ?? null) === null) {
+    return trustedSql("NULL");
+  }
+  if (typeof (value ?? null) === "boolean") {
+    return trustedSql(((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "boolean", "bool", "value", 24937))(value) ? "1" : "0");
+  }
+  if (typeof (value ?? null) === "string") {
+    return trustedSql("'" + __velarStringReplaceAll(((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "string", "string", "value", 25012))(value), "'", "''") + "'");
+  }
+  if (typeof (value ?? null) === "number") {
+    if (!__velarNumberIsFinite(((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "number", "number", "value", 25086))(value))) {
+      throw new __VelarAssertionError("SQLite numeric literals must be finite");
+    }
+    if (!(!__velarNumberIsInteger(((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "number", "number", "value", 25168))(value)) || ((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "number", "number", "value", 25190))(value) >= -9007199254740991 && ((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "number", "number", "value", 25221))(value) <= 9007199254740991)) {
+      throw new __VelarAssertionError("SQLite integer literals must be safe integers");
+    }
+    return trustedSql(String(((__velarValue) => __velarNarrow(__velarValue, typeof __velarValue === "number", "number", "value", 25331))(value)));
+  }
+  throw new Error("SQLite literals support only null, bool, string, and finite number");
+}
+function sqliteIdentifier(value) {
+  if (!(!__velarStringIsBlank(value) && __velarStringSize(value) <= 255 && !__velarStringHas(value, fromCodePoint(0)))) {
+    throw new __VelarAssertionError("SQLite identifiers must be non-blank text with no NUL and no longer than 255 characters");
+  }
+  return trustedSql('"' + __velarStringReplaceAll(value, '"', '""') + '"');
+}
 var SqliteTransaction = class {
   #native;
   constructor(native) {
     this.#native = native;
     const self = this;
   }
-  async execute(sql, params = __velarAdoptList([])) {
+  async execute(statement) {
     const self = this;
+    const data = statement.data();
     try {
-      return await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").execute(sql, params));
+      return await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").execute(data.fragments, data.parameters));
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 21160))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 26288))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
   }
   executor() {
     const self = this;
-    async function executeStatement(text, parameters) {
-      return await __velarNormalizePromiseValue(self.execute(text, parameters));
+    async function executeStatement(statement) {
+      return await __velarNormalizePromiseValue(self.execute(statement));
     }
-    async function oneRow(text, parameters) {
+    async function oneRow(statement) {
+      const data = statement.data();
       try {
-        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(text, parameters)));
+        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(data.fragments, data.parameters)));
       } catch (error) {
         error = __velarNormalizeError(error);
         if (error instanceof NativeSqliteError) {
-          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 21753))(error));
+          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 26909))(error));
         }
         throw new SqliteError(__velarReadInstanceField(error, "message"));
       }
     }
-    async function allRows(text, parameters) {
+    async function allRows(statement) {
+      const data = statement.data();
       try {
-        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(text, parameters)));
+        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(data.fragments, data.parameters)));
       } catch (error) {
         error = __velarNormalizeError(error);
         if (error instanceof NativeSqliteError) {
-          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 22087))(error));
+          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 27289))(error));
         }
         throw new SqliteError(__velarReadInstanceField(error, "message"));
       }
     }
     return { execute: executeStatement, one: oneRow, all: allRows };
   }
-  async one(sql, RowType, params = __velarAdoptList([])) {
+  async one(statement, RowType) {
     const self = this;
+    const data = statement.data();
     try {
-      const row = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(sql, params));
+      const row = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(data.fragments, data.parameters));
       if ((row ?? null) === null) {
         return null;
       }
@@ -1355,20 +1770,21 @@ var SqliteTransaction = class {
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 22568))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 27817))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
   }
-  async all(sql, RowType, params = __velarAdoptList([])) {
+  async all(statement, RowType) {
     const self = this;
+    const data = statement.data();
     try {
-      const rows = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(sql, params));
+      const rows = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(data.fragments, data.parameters));
       return __velarAsyncResolvedValue(__velarListMap(rows, (row) => RowType.parse(row ?? null)));
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 22941))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 28237))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
@@ -1380,51 +1796,55 @@ var SqliteConnection = class {
     this.#native = native;
     const self = this;
   }
-  async execute(sql, params = __velarAdoptList([])) {
+  async execute(statement) {
     const self = this;
+    const data = statement.data();
     try {
-      return await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").execute(sql, params));
+      return await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").execute(data.fragments, data.parameters));
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 23347))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 28690))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
   }
   executor() {
     const self = this;
-    async function executeStatement(text, parameters) {
-      return await __velarNormalizePromiseValue(self.execute(text, parameters));
+    async function executeStatement(statement) {
+      return await __velarNormalizePromiseValue(self.execute(statement));
     }
-    async function oneRow(text, parameters) {
+    async function oneRow(statement) {
+      const data = statement.data();
       try {
-        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(text, parameters)));
+        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(data.fragments, data.parameters)));
       } catch (error) {
         error = __velarNormalizeError(error);
         if (error instanceof NativeSqliteError) {
-          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 23939))(error));
+          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 29310))(error));
         }
         throw new SqliteError(__velarReadInstanceField(error, "message"));
       }
     }
-    async function allRows(text, parameters) {
+    async function allRows(statement) {
+      const data = statement.data();
       try {
-        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(text, parameters)));
+        return __velarAsyncResolvedValue(await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(data.fragments, data.parameters)));
       } catch (error) {
         error = __velarNormalizeError(error);
         if (error instanceof NativeSqliteError) {
-          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24273))(error));
+          throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 29690))(error));
         }
         throw new SqliteError(__velarReadInstanceField(error, "message"));
       }
     }
     return { execute: executeStatement, one: oneRow, all: allRows };
   }
-  async one(sql, RowType, params = __velarAdoptList([])) {
+  async one(statement, RowType) {
     const self = this;
+    const data = statement.data();
     try {
-      const row = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(sql, params));
+      const row = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").one(data.fragments, data.parameters));
       if ((row ?? null) === null) {
         return null;
       }
@@ -1432,20 +1852,21 @@ var SqliteConnection = class {
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 24754))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 30218))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
   }
-  async all(sql, RowType, params = __velarAdoptList([])) {
+  async all(statement, RowType) {
     const self = this;
+    const data = statement.data();
     try {
-      const rows = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(sql, params));
+      const rows = await __velarNormalizePromiseValue(__velarReadPrivateField(self.#native, "native").all(data.fragments, data.parameters));
       return __velarAsyncResolvedValue(__velarListMap(rows, (row) => RowType.parse(row ?? null)));
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 25127))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 30638))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
@@ -1466,7 +1887,7 @@ var SqliteConnection = class {
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 25714))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 31225))(error));
       }
       throw error;
     }
@@ -1478,7 +1899,7 @@ var SqliteConnection = class {
     } catch (error) {
       error = __velarNormalizeError(error);
       if (error instanceof NativeSqliteError) {
-        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 25920))(error));
+        throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 31431))(error));
       }
       throw new SqliteError(__velarReadInstanceField(error, "message"));
     }
@@ -1496,7 +1917,7 @@ async function openSqlite(path, options = {}) {
   } catch (error) {
     error = __velarNormalizeError(error);
     if (error instanceof NativeSqliteError) {
-      throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 26275))(error));
+      throw sqliteFailure(((__velarValue) => __velarNarrow(__velarValue, __velarValidationIsInstance(__velarValue, NativeSqliteError), "NativeSqliteError", "error", 31786))(error));
     }
     throw new SqliteError(__velarReadInstanceField(error, "message"));
   }
@@ -1506,7 +1927,10 @@ export {
   SqliteConcurrencyError,
   SqliteConnection,
   SqliteError,
+  SqliteJournalMode,
   SqliteOptions,
   SqliteTransaction,
-  openSqlite
+  openSqlite,
+  sqliteIdentifier,
+  sqliteLiteral
 };