dbgate-sqlite-dumper 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3902 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BufferDumpWriter: () => BufferDumpWriter,
+  COMPLETE_TRANSITIONS: () => COMPLETE_TRANSITIONS,
+  CompleteToken: () => CompleteToken,
+  DEFENSIVE_WARNING_COMMENT: () => DEFENSIVE_WARNING_COMMENT,
+  InvalidTextEncodingError: () => InvalidTextEncodingError,
+  MalformedSqlDumpError: () => MalformedSqlDumpError,
+  OperationCancelledError: () => OperationCancelledError,
+  RestoreError: () => RestoreError,
+  RestoreExecutionError: () => RestoreExecutionError,
+  RestoreSessionState: () => RestoreSessionState,
+  SEQUENCE_TABLE_NAME: () => SEQUENCE_TABLE_NAME,
+  SESSION_GUARD_FOOTER: () => SESSION_GUARD_FOOTER,
+  SESSION_GUARD_HEADER: () => SESSION_GUARD_HEADER,
+  SQLITE_KEYWORD_COUNT: () => SQLITE_KEYWORD_COUNT,
+  SqlChunkBuilder: () => SqlChunkBuilder,
+  SqlParseError: () => SqlParseError,
+  SqlStatementParser: () => SqlStatementParser,
+  SqliteDumperError: () => SqliteDumperError,
+  StatementTooLargeError: () => StatementTooLargeError,
+  StreamDumpWriter: () => StreamDumpWriter,
+  UNSUPPORTED_FEATURES: () => UNSUPPORTED_FEATURES,
+  UnsupportedClientCommandError: () => UnsupportedClientCommandError,
+  WRITABLE_SCHEMA_OFF: () => WRITABLE_SCHEMA_OFF,
+  WRITABLE_SCHEMA_ON: () => WRITABLE_SCHEMA_ON,
+  acquireSqliteConnection: () => acquireSqliteConnection,
+  assignDumpSection: () => assignDumpSection,
+  beginSqliteDumpSession: () => beginSqliteDumpSession,
+  checkTargetCompatibility: () => checkTargetCompatibility,
+  classifyWord: () => classifyWord,
+  columnValueSelect: () => columnValueSelect,
+  completeTransition: () => completeTransition,
+  createArchiveIdentity: () => createArchiveIdentity,
+  createCanonicalIdentity: () => createCanonicalIdentity,
+  createDumpId: () => createDumpId,
+  declaresAutoincrement: () => declaresAutoincrement,
+  decodeStatementBytes: () => decodeStatementBytes,
+  describeStatement: () => describeStatement,
+  detectSqliteCapabilities: () => detectSqliteCapabilities,
+  detectSqliteVersion: () => detectSqliteVersion,
+  detectTargetCapabilities: () => detectSqliteCapabilities,
+  dumpSectionPriority: () => dumpSectionPriority,
+  dumpSqlite: () => dumpSqlite,
+  executeStatement: () => executeStatement,
+  exportTableDataAsInserts: () => exportTableDataAsInserts,
+  foldSqliteName: () => foldSqliteName,
+  insertableColumns: () => insertableColumns,
+  inspectDumpArchive: () => inspectDumpArchive,
+  introspectSqlite: () => introspectSqlite,
+  isAbortError: () => isAbortError,
+  isCompleteStatement: () => isCompleteStatement,
+  isIdentifierCharCode: () => isIdentifierCharCode,
+  isIndexSelected: () => isIndexSelected,
+  isSchemaTableName: () => isSchemaTableName,
+  isSqliteConnectionSource: () => isSqliteConnectionSource,
+  isSqliteDump: () => isSqliteDump,
+  isSqliteKeyword: () => isSqliteKeyword,
+  isStatisticsTableName: () => isStatisticsTableName,
+  isTableDataExcluded: () => isTableDataExcluded,
+  isTableSelected: () => isTableSelected,
+  isTriggerSelected: () => isTriggerSelected,
+  isTruthyPragmaValue: () => isTruthyPragmaValue,
+  isViewSelected: () => isViewSelected,
+  maskSqlLiterals: () => maskSqlLiterals,
+  needsIdentifierQuoting: () => needsIdentifierQuoting,
+  normalizeDumpSelection: () => normalizeDumpSelection,
+  parseSqlStatements: () => parseSqlStatements,
+  parseSqliteVersion: () => parseSqliteVersion,
+  parseTableOptions: () => parseTableOptions,
+  parseVirtualTableModule: () => parseVirtualTableModule,
+  preflightRestore: () => preflightRestore,
+  preservableRowidName: () => preservableRowidName,
+  quoteIdentifier: () => quoteIdentifier,
+  quoteIdentifierIfNeeded: () => quoteIdentifierIfNeeded,
+  quoteQualifiedIdentifier: () => quoteQualifiedIdentifier,
+  quoteStringLiteral: () => quoteStringLiteral,
+  redactSecrets: () => redactSecrets,
+  renderBlobLiteral: () => renderBlobLiteral,
+  renderColumnLiteral: () => renderColumnLiteral,
+  renderDatabaseSettings: () => renderDatabaseSettings,
+  renderDrop: () => renderDrop,
+  renderEscapedStringLiteral: () => renderEscapedStringLiteral,
+  renderPlainSql: () => renderPlainSql,
+  renderQuotedStringLiteral: () => renderQuotedStringLiteral,
+  renderSchemaLine: () => renderSchemaLine,
+  renderSchemaObject: () => renderSchemaObject,
+  renderSystemTablePrelude: () => renderSystemTablePrelude,
+  renderTextLiteral: () => renderTextLiteral,
+  renderVirtualTable: () => renderVirtualTable,
+  resolvePlainSqlRenderOptions: () => resolvePlainSqlRenderOptions,
+  restoreSqlDump: () => restoreSqlDump,
+  safeSqlPreview: () => safeSqlPreview,
+  streamSqlStatements: () => streamSqlStatements,
+  streamWithParser: () => streamWithParser,
+  tableGroupPriority: () => tableGroupPriority,
+  throwIfAborted: () => throwIfAborted2,
+  toAsciiLowerCase: () => toAsciiLowerCase,
+  toAsciiUpperCase: () => toAsciiUpperCase,
+  toByteStringChunks: () => toByteStringChunks,
+  toNumber: () => toNumber,
+  toText: () => toText,
+  unsupportedFeatureDiagnostics: () => unsupportedFeatureDiagnostics
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/connection/types.ts
+function isSqliteConnectionSource(input) {
+  return typeof input.acquire === "function";
+}
+
+// src/connection/acquire.ts
+async function acquireSqliteConnection(input, signal) {
+  if (isSqliteConnectionSource(input)) {
+    return input.acquire(signal);
+  }
+  return {
+    connection: input,
+    dedicated: false,
+    release: async () => {
+    }
+  };
+}
+async function executeStatement(connection, sql, signal) {
+  if (connection.execute) {
+    return connection.execute(sql, signal);
+  }
+  await connection.query({ sql }, signal);
+  return { changes: 0 };
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+    return Number(value);
+  }
+  return fallback;
+}
+function toText(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("utf8");
+  }
+  return String(value);
+}
+
+// src/connection/session.ts
+var DUMP_SAVEPOINT = "dbgate_sqlite_dump";
+async function beginSqliteDumpSession(connection, options, signal) {
+  const consistency = options?.consistency ?? "snapshot";
+  const joinedExistingTransaction = connection.isInTransaction?.() ?? false;
+  if (consistency === "none") {
+    return { consistency, joinedExistingTransaction, finish: async () => {
+    } };
+  }
+  await executeStatement(connection, `SAVEPOINT ${DUMP_SAVEPOINT}`, signal);
+  let finished = false;
+  const finish = async () => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    await executeStatement(connection, `RELEASE ${DUMP_SAVEPOINT}`).catch(() => {
+    });
+  };
+  try {
+    await connection.query({ sql: "SELECT count(*) AS n FROM sqlite_master" }, signal);
+  } catch (error) {
+    await finish();
+    throw error;
+  }
+  return { consistency, joinedExistingTransaction, finish };
+}
+
+// src/version/types.ts
+function parseSqliteVersion(versionString) {
+  const match = /^(\d+)\.(\d+)(?:\.(\d+))?/.exec(versionString.trim());
+  if (!match) {
+    throw new Error(`Cannot parse SQLite version string: ${JSON.stringify(versionString)}`);
+  }
+  const majorVersion = Number(match[1]);
+  const minorVersion = Number(match[2]);
+  const patchVersion = match[3] === void 0 ? 0 : Number(match[3]);
+  return {
+    majorVersion,
+    minorVersion,
+    patchVersion,
+    versionNumber: majorVersion * 1e6 + minorVersion * 1e3 + patchVersion
+  };
+}
+
+// src/version/detect.ts
+async function detectSqliteVersion(connection, signal) {
+  const result = await connection.query(
+    { sql: "SELECT sqlite_version() AS versionString" },
+    signal
+  );
+  const versionString = toText(result.rows[0]?.versionString);
+  if (!versionString) {
+    throw new Error("Unable to detect SQLite version: sqlite_version() returned no data");
+  }
+  let sourceId;
+  try {
+    const source = await connection.query(
+      { sql: "SELECT sqlite_source_id() AS sourceId" },
+      signal
+    );
+    sourceId = toText(source.rows[0]?.sourceId) ?? void 0;
+  } catch {
+  }
+  return {
+    versionString,
+    ...parseSqliteVersion(versionString),
+    ...sourceId === void 0 ? {} : { sourceId }
+  };
+}
+
+// src/version/capabilities.ts
+function detectSqliteCapabilities(version) {
+  const atLeast = (target) => version.versionNumber >= target;
+  return {
+    supportsWithoutRowid: atLeast(3008002),
+    supportsMultiRowValues: atLeast(3007011),
+    supportsPragmaFunctions: atLeast(3016e3),
+    supportsTableXinfo: atLeast(3026e3),
+    supportsGeneratedColumns: atLeast(3031e3),
+    supportsSqliteSchemaAlias: atLeast(3033e3),
+    supportsWritableSchemaReset: atLeast(3035e3),
+    supportsStrictTables: atLeast(3037e3),
+    supportsTableList: atLeast(3037e3)
+  };
+}
+
+// src/security/identifiers.ts
+var SQLITE_KEYWORDS = new Set(
+  `ABORT ACTION ADD AFTER ALL ALTER ALWAYS ANALYZE AND AS ASC ATTACH AUTOINCREMENT BEFORE BEGIN
+  BETWEEN BY CASCADE CASE CAST CHECK COLLATE COLUMN COMMIT CONFLICT CONSTRAINT CREATE CROSS
+  CURRENT CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP DATABASE DEFAULT DEFERRABLE DEFERRED DELETE
+  DESC DETACH DISTINCT DO DROP EACH ELSE END ESCAPE EXCEPT EXCLUDE EXCLUSIVE EXISTS EXPLAIN FAIL
+  FILTER FIRST FOLLOWING FOR FOREIGN FROM FULL GENERATED GLOB GROUP GROUPS HAVING IF IGNORE
+  IMMEDIATE IN INDEX INDEXED INITIALLY INNER INSERT INSTEAD INTERSECT INTO IS ISNULL JOIN KEY LAST
+  LEFT LIKE LIMIT MATCH MATERIALIZED NATURAL NO NOT NOTHING NOTNULL NULL NULLS OF OFFSET ON OR
+  ORDER OTHERS OUTER OVER PARTITION PLAN PRAGMA PRECEDING PRIMARY QUERY RAISE RANGE RECURSIVE
+  REFERENCES REGEXP REINDEX RELEASE RENAME REPLACE RESTRICT RETURNING RIGHT ROLLBACK ROW ROWS
+  SAVEPOINT SELECT SET TABLE TEMP TEMPORARY THEN TIES TO TRANSACTION TRIGGER UNBOUNDED UNION
+  UNIQUE UPDATE USING VACUUM VALUES VIEW VIRTUAL WHEN WHERE WINDOW WITH WITHOUT`.split(/\s+/).filter((word) => word !== "")
+);
+function isSqliteKeyword(name) {
+  return SQLITE_KEYWORDS.has(toAsciiUpperCase(name));
+}
+var SQLITE_KEYWORD_COUNT = SQLITE_KEYWORDS.size;
+function isAsciiAlpha(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isAsciiDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function toAsciiUpperCase(value) {
+  return value.replace(/[a-z]+/g, (run) => run.toUpperCase());
+}
+function toAsciiLowerCase(value) {
+  return value.replace(/[A-Z]+/g, (run) => run.toLowerCase());
+}
+function needsIdentifierQuoting(name) {
+  if (name.length === 0) {
+    return true;
+  }
+  const first = name.charCodeAt(0);
+  if (!isAsciiAlpha(first) && first !== 95) {
+    return true;
+  }
+  for (let index = 0; index < name.length; index++) {
+    const code = name.charCodeAt(index);
+    if (!isAsciiAlpha(code) && !isAsciiDigit(code) && code !== 95) {
+      return true;
+    }
+  }
+  return isSqliteKeyword(name);
+}
+function quoteIdentifier(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function quoteIdentifierIfNeeded(name) {
+  return needsIdentifierQuoting(name) ? quoteIdentifier(name) : name;
+}
+function quoteQualifiedIdentifier(schemaName, name) {
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(name)}`;
+}
+
+// src/selection/normalize.ts
+function foldSqliteName(name) {
+  return toAsciiLowerCase(name);
+}
+function toSet(names) {
+  return names ? new Set(names.map(foldSqliteName)) : void 0;
+}
+function normalizeDumpSelection(selection) {
+  const normalized = {
+    tables: toSet(selection?.tables),
+    excludeTables: new Set((selection?.excludeTables ?? []).map(foldSqliteName)),
+    views: toSet(selection?.views),
+    excludeViews: new Set((selection?.excludeViews ?? []).map(foldSqliteName)),
+    triggers: toSet(selection?.triggers),
+    excludeTriggers: new Set((selection?.excludeTriggers ?? []).map(foldSqliteName)),
+    excludeIndexes: new Set((selection?.excludeIndexes ?? []).map(foldSqliteName)),
+    dataExcludedTables: new Set((selection?.dataExcludedTables ?? []).map(foldSqliteName))
+  };
+  const isPartial = normalized.tables !== void 0 || normalized.views !== void 0 || normalized.triggers !== void 0 || normalized.excludeTables.size > 0 || normalized.excludeViews.size > 0 || normalized.excludeTriggers.size > 0 || normalized.excludeIndexes.size > 0;
+  return { ...normalized, isPartial };
+}
+function isSelected(name, include, exclude) {
+  const key = foldSqliteName(name);
+  if (exclude.has(key)) {
+    return false;
+  }
+  return include ? include.has(key) : true;
+}
+function isTableSelected(name, selection) {
+  return isSelected(name, selection.tables, selection.excludeTables);
+}
+function isViewSelected(name, selection) {
+  return isSelected(name, selection.views, selection.excludeViews);
+}
+function isTriggerSelected(name, selection) {
+  return isSelected(name, selection.triggers, selection.excludeTriggers);
+}
+function isIndexSelected(name, selection) {
+  return !selection.excludeIndexes.has(foldSqliteName(name));
+}
+function isTableDataExcluded(name, selection) {
+  return selection.dataExcludedTables.has(foldSqliteName(name));
+}
+
+// src/security/literals.ts
+function unusedString(text, a, b) {
+  if (!text.includes(a)) {
+    return a;
+  }
+  if (!text.includes(b)) {
+    return b;
+  }
+  for (let counter = 0; ; counter++) {
+    const candidate = `(${a}${counter})`;
+    if (!text.includes(candidate)) {
+      return candidate;
+    }
+  }
+}
+function renderQuotedStringLiteral(text) {
+  return `'${text.replace(/'/g, "''")}'`;
+}
+function renderEscapedStringLiteral(text) {
+  if (!text.includes("\n") && !text.includes("\r")) {
+    return renderQuotedStringLiteral(text);
+  }
+  const hasNewline = text.includes("\n");
+  const hasCarriageReturn = text.includes("\r");
+  const newlinePlaceholder = hasNewline ? unusedString(text, "\\n", "\\012") : "";
+  const carriageReturnPlaceholder = hasCarriageReturn ? unusedString(text, "\\r", "\\015") : "";
+  let body = "";
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (character === "'") {
+      body += "''";
+    } else if (character === "\n") {
+      body += newlinePlaceholder;
+    } else if (character === "\r") {
+      body += carriageReturnPlaceholder;
+    } else {
+      body += character;
+    }
+  }
+  let literal = `${hasNewline ? "replace(" : ""}${hasCarriageReturn ? "replace(" : ""}'${body}'`;
+  if (hasCarriageReturn) {
+    literal += `,'${carriageReturnPlaceholder}',char(13))`;
+  }
+  if (hasNewline) {
+    literal += `,'${newlinePlaceholder}',char(10))`;
+  }
+  return literal;
+}
+function renderTextLiteral(text, style = "escaped") {
+  const render = style === "escaped" ? renderEscapedStringLiteral : renderQuotedStringLiteral;
+  if (!text.includes("\0")) {
+    return render(text);
+  }
+  return text.split("\0").map(render).join("||char(0)||");
+}
+function renderBlobLiteral(value) {
+  return `X'${Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("hex")}'`;
+}
+function quoteStringLiteral(text) {
+  return renderQuotedStringLiteral(text);
+}
+
+// src/security/redact.ts
+var SQL_SECRET_PATTERNS = [
+  // PRAGMA [schema.]key = 'secret' / PRAGMA key('secret'), and the rekey/hexkey/textkey forms
+  /(\bPRAGMA\s+(?:[\w"`[\]]+\s*\.\s*)?(?:hex|text)?(?:re)?key\s*(?:=\s*|\(\s*))(?:'(?:[^']|'')*'|"(?:[^"]|"")*"|[^\s;)]+)/gi,
+  // ATTACH DATABASE 'file' AS name KEY 'secret'
+  /(\bATTACH\b[\s\S]*?\bKEY\s+)(?:'(?:[^']|'')*'|"(?:[^"]|"")*"|X'[0-9A-Fa-f]*'|[^\s;)]+)/gi
+];
+function redactSecrets(text) {
+  return SQL_SECRET_PATTERNS.reduce(
+    (result, pattern) => result.replace(pattern, (_match, prefix) => `${prefix}'***REDACTED***'`),
+    text
+  );
+}
+
+// src/writer/streamWriter.ts
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new DOMException("The operation was aborted.", "AbortError");
+  }
+}
+var StreamDumpWriter = class {
+  stream;
+  bytes = 0;
+  writeError = null;
+  constructor(stream) {
+    this.stream = stream;
+  }
+  get bytesWritten() {
+    return this.bytes;
+  }
+  async write(chunk, signal) {
+    if (chunk.length === 0) {
+      return;
+    }
+    if (this.writeError) {
+      throw this.writeError;
+    }
+    throwIfAborted(signal);
+    const isBuffer = Buffer.isBuffer(chunk);
+    this.bytes += isBuffer ? chunk.length : Buffer.byteLength(chunk, "utf8");
+    const onWritten = (error) => {
+      if (error && !this.writeError) {
+        this.writeError = error;
+      }
+    };
+    const canWriteMore = isBuffer ? this.stream.write(chunk, onWritten) : this.stream.write(chunk, "utf8", onWritten);
+    if (canWriteMore === false) {
+      await new Promise((resolve, reject) => {
+        const cleanup = () => {
+          this.stream.removeListener("drain", onDrain);
+          this.stream.removeListener("error", onError);
+          signal?.removeEventListener("abort", onAbort);
+        };
+        const onDrain = () => {
+          cleanup();
+          resolve();
+        };
+        const onError = (error) => {
+          cleanup();
+          reject(error);
+        };
+        const onAbort = () => {
+          cleanup();
+          reject(new DOMException("The operation was aborted.", "AbortError"));
+        };
+        this.stream.once("drain", onDrain);
+        this.stream.once("error", onError);
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+    if (this.writeError) {
+      throw this.writeError;
+    }
+    throwIfAborted(signal);
+  }
+};
+
+// src/writer/bufferWriter.ts
+var BufferDumpWriter = class {
+  chunks = [];
+  bytes = 0;
+  get bytesWritten() {
+    return this.bytes;
+  }
+  async write(chunk, signal) {
+    if (signal?.aborted) {
+      throw new DOMException("The operation was aborted.", "AbortError");
+    }
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+    this.chunks.push(buffer);
+    this.bytes += buffer.length;
+  }
+  toBuffer() {
+    return Buffer.concat(this.chunks);
+  }
+  toString() {
+    return this.toBuffer().toString("utf8");
+  }
+};
+
+// src/archive/sectionRules.ts
+var SECTION_BY_OBJECT_TYPE = {
+  table: "tables",
+  tableData: "tables",
+  virtualTable: "tables",
+  index: "schema",
+  trigger: "schema",
+  view: "schema"
+};
+var SECTION_PRIORITY = {
+  tables: 0,
+  schema: 1
+};
+var TABLE_GROUP_PRIORITY = {
+  table: 0,
+  virtualTable: 0,
+  tableData: 1,
+  index: 0,
+  trigger: 0,
+  view: 0
+};
+function assignDumpSection(objectType) {
+  return SECTION_BY_OBJECT_TYPE[objectType];
+}
+function dumpSectionPriority(section) {
+  return SECTION_PRIORITY[section];
+}
+function tableGroupPriority(objectType) {
+  return TABLE_GROUP_PRIORITY[objectType];
+}
+
+// src/utils/hash.ts
+var import_node_crypto = require("crypto");
+function createCanonicalIdentity(parts) {
+  return parts.map((part) => `${part.length}:${part}`).join("|");
+}
+function createDumpId(identity) {
+  return (0, import_node_crypto.createHash)("sha1").update(identity, "utf8").digest("hex").slice(0, 16);
+}
+
+// src/archive/identity.ts
+function createArchiveIdentity(input) {
+  return createCanonicalIdentity([
+    input.objectType,
+    input.schemaName,
+    input.name,
+    input.parentName ?? ""
+  ]);
+}
+
+// src/archive/planner.ts
+function isStatisticsTableName(name) {
+  return /^sqlite_stat[\s\S]$/.test(name);
+}
+var SEQUENCE_TABLE_NAME = "sqlite_sequence";
+function inspectDumpArchive(database, options = {}) {
+  const mode = options.mode ?? "full";
+  const selection = options.selection ?? normalizeDumpSelection();
+  const kinds = options.objectKinds ?? {};
+  const includeTables = kinds.includeTables ?? true;
+  const includeViews = kinds.includeViews ?? true;
+  const includeIndexes = kinds.includeIndexes ?? true;
+  const includeTriggers = kinds.includeTriggers ?? true;
+  const includeVirtualTables = kinds.includeVirtualTables ?? true;
+  const includeSystemTables = kinds.includeSystemTables ?? true;
+  const wantsSchema = mode !== "data-only";
+  const wantsData = mode !== "schema-only";
+  const schemaName = database.schemaName;
+  const diagnostics = [];
+  const entries = [];
+  const byDumpId = /* @__PURE__ */ new Map();
+  function addEntry(objectType, name, extra = {}) {
+    const identity = createArchiveIdentity({
+      objectType,
+      schemaName,
+      name,
+      ...extra.parentName === void 0 ? {} : { parentName: extra.parentName }
+    });
+    const dumpId = createDumpId(identity);
+    if (byDumpId.has(dumpId)) {
+      diagnostics.push({
+        severity: "error",
+        code: "duplicate-archive-identity",
+        message: `Duplicate archive identity for ${objectType} "${name}" in schema "${schemaName}"`,
+        objectReference: { kind: "table", schemaName, name }
+      });
+      return dumpId;
+    }
+    const entry = { dumpId, identity, objectType, name, ...extra, dependsOn: [] };
+    entries.push(entry);
+    byDumpId.set(dumpId, entry);
+    return dumpId;
+  }
+  function addDependency(fromDumpId, toDumpId, strength) {
+    if (!toDumpId || fromDumpId === toDumpId) {
+      return;
+    }
+    const entry = byDumpId.get(fromDumpId);
+    if (!entry) {
+      return;
+    }
+    const existing = entry.dependsOn.find((dependency) => dependency.targetDumpId === toDumpId);
+    if (existing) {
+      if (strength === "hard" && existing.strength === "preference") {
+        entry.dependsOn = entry.dependsOn.filter(
+          (dependency) => dependency.targetDumpId !== toDumpId
+        );
+        entry.dependsOn.push({ targetDumpId: toDumpId, strength: "hard" });
+      }
+      return;
+    }
+    entry.dependsOn.push({ targetDumpId: toDumpId, strength });
+  }
+  const tablesByName = new Map(database.tables.map((table) => [foldSqliteName(table.name), table]));
+  const isUserTableSelected = (table) => {
+    switch (table.kind) {
+      case "table":
+        return includeTables && isTableSelected(table.name, selection);
+      case "virtual":
+        return includeVirtualTables && isTableSelected(table.name, selection);
+      case "shadow": {
+        const owner = table.ownerVirtualTable === void 0 ? void 0 : tablesByName.get(foldSqliteName(table.ownerVirtualTable));
+        if (!owner) {
+          return includeTables && isTableSelected(table.name, selection);
+        }
+        return includeVirtualTables && isTableSelected(owner.name, selection);
+      }
+      case "system":
+        return false;
+    }
+  };
+  const selectedUserTables = database.tables.filter(isUserTableSelected);
+  const selectedTableNames = selectedUserTables.map((table) => table.name);
+  const tableDumpId = /* @__PURE__ */ new Map();
+  const tableDataDumpId = /* @__PURE__ */ new Map();
+  const orderedTables = [...database.tables].sort((a, b) => {
+    const aLast = a.name === SEQUENCE_TABLE_NAME ? 1 : 0;
+    const bLast = b.name === SEQUENCE_TABLE_NAME ? 1 : 0;
+    return aLast - bLast || a.schemaRowid - b.schemaRowid;
+  });
+  for (const table of orderedTables) {
+    const key = foldSqliteName(table.name);
+    if (table.kind === "system") {
+      const isSequence = table.name === SEQUENCE_TABLE_NAME;
+      if (!includeSystemTables || !isSequence && !isStatisticsTableName(table.name)) {
+        continue;
+      }
+      const systemRowFilter = selection.isPartial ? selectedTableNames : void 0;
+      if (systemRowFilter && systemRowFilter.length === 0) {
+        continue;
+      }
+      const extra = {
+        tableKind: table.kind,
+        ...systemRowFilter === void 0 ? {} : { systemRowFilter }
+      };
+      let structureId2;
+      if (wantsSchema && wantsData) {
+        structureId2 = addEntry("table", table.name, extra);
+        tableDumpId.set(key, structureId2);
+      }
+      if (wantsData) {
+        const dataId = addEntry("tableData", table.name, { ...extra, parentName: table.name });
+        tableDataDumpId.set(key, dataId);
+        addDependency(dataId, structureId2, "hard");
+        if (!wantsSchema) {
+          diagnostics.push({
+            severity: "warning",
+            code: "data-only-system-table",
+            message: isSequence ? "A data-only dump inserts the sqlite_sequence rows without first clearing the table, exactly as the native .dump --data-only does; restoring it into a database whose tables already advanced their AUTOINCREMENT counters leaves duplicate counter rows. Set objectKinds.includeSystemTables to false to leave the counters to the inserts themselves." : `A data-only dump inserts into ${table.name} without creating it first, exactly as the native .dump --data-only does; restoring it into a database that has never been analyzed fails with "no such table". Set objectKinds.includeSystemTables to false to leave statistics out.`,
+            objectReference: { kind: "table", schemaName, name: table.name }
+          });
+        }
+      }
+      continue;
+    }
+    if (!isUserTableSelected(table)) {
+      continue;
+    }
+    if (table.kind === "virtual") {
+      if (wantsSchema) {
+        tableDumpId.set(key, addEntry("virtualTable", table.name, { tableKind: table.kind }));
+      } else if (!isTableDataExcluded(table.name, selection)) {
+        tableDataDumpId.set(
+          key,
+          addEntry("tableData", table.name, { tableKind: table.kind, parentName: table.name })
+        );
+        diagnostics.push({
+          severity: "warning",
+          code: "data-only-virtual-table",
+          message: `A data-only dump carries the rows of virtual table "${table.name}" twice \u2014 through the table itself and in its shadow tables \u2014 exactly as the native .dump --data-only does. Restoring it into a database where "${table.name}" already exists conflicts with that table's own shadow rows; exclude the shadow tables through selection.dataExcludedTables to load the rows through the virtual table only.`,
+          objectReference: { kind: "virtualTable", schemaName, name: table.name }
+        });
+      }
+      continue;
+    }
+    if (table.kind === "shadow" && !wantsData && table.ownerVirtualTable !== void 0) {
+      continue;
+    }
+    let structureId;
+    if (wantsSchema) {
+      structureId = addEntry("table", table.name, { tableKind: table.kind });
+      tableDumpId.set(key, structureId);
+      if (table.kind === "shadow" && table.ownerVirtualTable !== void 0) {
+        addDependency(
+          structureId,
+          tableDumpId.get(foldSqliteName(table.ownerVirtualTable)),
+          "preference"
+        );
+      }
+    }
+    if (wantsData && !isTableDataExcluded(table.name, selection)) {
+      const dataId = addEntry("tableData", table.name, {
+        tableKind: table.kind,
+        parentName: table.name
+      });
+      tableDataDumpId.set(key, dataId);
+      addDependency(dataId, structureId, "hard");
+    }
+  }
+  for (const foreignKey of database.foreignKeys) {
+    const from = tableDumpId.get(foldSqliteName(foreignKey.tableName));
+    const to = tableDumpId.get(foldSqliteName(foreignKey.referencedTableName));
+    if (from && to) {
+      addDependency(from, to, "preference");
+    }
+  }
+  if (wantsSchema) {
+    const selectedViewNames = new Set(
+      includeViews ? database.views.filter((view) => isViewSelected(view.name, selection)).map((view) => foldSqliteName(view.name)) : []
+    );
+    const viewDumpId = /* @__PURE__ */ new Map();
+    const objects = [
+      ...database.indexes.map((index) => ({
+        kind: "index",
+        schemaRowid: index.schemaRowid,
+        index
+      })),
+      ...database.triggers.map((trigger) => ({
+        kind: "trigger",
+        schemaRowid: trigger.schemaRowid,
+        trigger
+      })),
+      ...database.views.map((view) => ({
+        kind: "view",
+        schemaRowid: view.schemaRowid,
+        view
+      }))
+    ].sort((a, b) => a.schemaRowid - b.schemaRowid);
+    for (const object of objects) {
+      switch (object.kind) {
+        case "index": {
+          const { index } = object;
+          if (index.sql === null || !includeIndexes || !isIndexSelected(index.name, selection)) {
+            continue;
+          }
+          const tableId = tableDumpId.get(foldSqliteName(index.tableName));
+          if (!tableId) {
+            continue;
+          }
+          const dumpId = addEntry("index", index.name, { parentName: index.tableName });
+          addDependency(dumpId, tableId, "hard");
+          addDependency(dumpId, tableDataDumpId.get(foldSqliteName(index.tableName)), "preference");
+          break;
+        }
+        case "trigger": {
+          const { trigger } = object;
+          if (!includeTriggers || !isTriggerSelected(trigger.name, selection)) {
+            continue;
+          }
+          const parentKey = foldSqliteName(trigger.tableName);
+          const parentId = tableDumpId.get(parentKey) ?? viewDumpId.get(parentKey);
+          if (!parentId) {
+            diagnostics.push({
+              severity: "info",
+              code: "trigger-table-not-selected",
+              message: `Trigger "${trigger.name}" is not dumped because its table "${trigger.tableName}" is not part of the dump`,
+              objectReference: {
+                kind: "trigger",
+                schemaName,
+                name: trigger.name,
+                parentName: trigger.tableName
+              }
+            });
+            continue;
+          }
+          const dumpId = addEntry("trigger", trigger.name, { parentName: trigger.tableName });
+          addDependency(dumpId, parentId, "hard");
+          addDependency(dumpId, tableDataDumpId.get(parentKey), "hard");
+          break;
+        }
+        case "view": {
+          const { view } = object;
+          const key = foldSqliteName(view.name);
+          if (!selectedViewNames.has(key)) {
+            continue;
+          }
+          const dumpId = addEntry("view", view.name);
+          viewDumpId.set(key, dumpId);
+          for (const tableId of tableDumpId.values()) {
+            addDependency(dumpId, tableId, "preference");
+          }
+          break;
+        }
+      }
+    }
+  }
+  const { cycles, unsatisfiedDependencies } = validateOrder(entries);
+  const valid = cycles.length === 0 && unsatisfiedDependencies.length === 0 && !diagnostics.some((diagnostic) => diagnostic.severity === "error");
+  for (const cycle of cycles) {
+    diagnostics.push({
+      severity: "error",
+      code: "archive-dependency-cycle",
+      message: `Hard dependency cycle between archive entries: ${cycle.memberDumpIds.join(", ")}`
+    });
+  }
+  for (const violation of unsatisfiedDependencies) {
+    diagnostics.push({
+      severity: "error",
+      code: "archive-order-violation",
+      message: `Archive entry ${violation.fromDumpId} is emitted before its hard dependency ${violation.toDumpId}`
+    });
+  }
+  return {
+    valid,
+    entries: entries.map(
+      (entry, index) => toArchiveEntry(entry, schemaName, valid ? index : void 0)
+    ),
+    diagnostics,
+    cycles,
+    unsatisfiedDependencies
+  };
+}
+function toArchiveEntry(entry, schemaName, sequenceNumber) {
+  return {
+    dumpId: entry.dumpId,
+    identity: entry.identity,
+    objectType: entry.objectType,
+    section: assignDumpSection(entry.objectType),
+    schemaName,
+    name: entry.name,
+    ...entry.parentName === void 0 ? {} : { parentName: entry.parentName },
+    ...entry.tableKind === void 0 ? {} : { tableKind: entry.tableKind },
+    ...entry.systemRowFilter === void 0 ? {} : { systemRowFilter: entry.systemRowFilter },
+    dependsOn: entry.dependsOn,
+    ...sequenceNumber === void 0 ? {} : { sequenceNumber }
+  };
+}
+function validateOrder(ordered) {
+  const positionByDumpId = new Map(ordered.map((entry, index) => [entry.dumpId, index]));
+  const unsatisfiedDependencies = [];
+  for (const entry of ordered) {
+    const fromPosition = positionByDumpId.get(entry.dumpId);
+    for (const dependency of entry.dependsOn) {
+      if (dependency.strength !== "hard") {
+        continue;
+      }
+      const toPosition = positionByDumpId.get(dependency.targetDumpId);
+      if (toPosition !== void 0 && toPosition > fromPosition) {
+        unsatisfiedDependencies.push({
+          fromDumpId: entry.dumpId,
+          toDumpId: dependency.targetDumpId
+        });
+      }
+    }
+  }
+  return { cycles: findHardCycles(ordered), unsatisfiedDependencies };
+}
+function byCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function findHardCycles(entries) {
+  const indexByDumpId = /* @__PURE__ */ new Map();
+  const lowLink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const byDumpId = new Map(entries.map((entry) => [entry.dumpId, entry]));
+  const cycles = [];
+  let nextIndex = 0;
+  const strongConnect = (dumpId) => {
+    indexByDumpId.set(dumpId, nextIndex);
+    lowLink.set(dumpId, nextIndex);
+    nextIndex++;
+    stack.push(dumpId);
+    onStack.add(dumpId);
+    for (const dependency of byDumpId.get(dumpId)?.dependsOn ?? []) {
+      if (dependency.strength !== "hard" || !byDumpId.has(dependency.targetDumpId)) {
+        continue;
+      }
+      const target = dependency.targetDumpId;
+      if (!indexByDumpId.has(target)) {
+        strongConnect(target);
+        lowLink.set(dumpId, Math.min(lowLink.get(dumpId), lowLink.get(target)));
+      } else if (onStack.has(target)) {
+        lowLink.set(
+          dumpId,
+          Math.min(lowLink.get(dumpId), indexByDumpId.get(target))
+        );
+      }
+    }
+    if (lowLink.get(dumpId) === indexByDumpId.get(dumpId)) {
+      const component = [];
+      for (; ; ) {
+        const member = stack.pop();
+        onStack.delete(member);
+        component.push(member);
+        if (member === dumpId) {
+          break;
+        }
+      }
+      if (component.length > 1) {
+        cycles.push({ memberDumpIds: component.sort(byCodepoint) });
+      }
+    }
+  };
+  for (const entry of entries) {
+    if (!indexByDumpId.has(entry.dumpId)) {
+      strongConnect(entry.dumpId);
+    }
+  }
+  return cycles;
+}
+
+// src/utils/errors.ts
+var SqliteDumperError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "SqliteDumperError";
+    this.code = code;
+  }
+};
+var OperationCancelledError = class extends SqliteDumperError {
+  constructor(message = "The operation was cancelled") {
+    super("operation-cancelled", message);
+    this.name = "OperationCancelledError";
+  }
+};
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw new OperationCancelledError();
+  }
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "OperationCancelledError";
+}
+
+// src/introspection/sqlText.ts
+function maskSqlLiterals(sql) {
+  let output = "";
+  let index = 0;
+  while (index < sql.length) {
+    const character = sql[index];
+    if (character === "'" || character === '"' || character === "`" || character === "[") {
+      const close = character === "[" ? "]" : character;
+      let end = sql.indexOf(close, index + 1);
+      end = end === -1 ? sql.length : end + 1;
+      output += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    if (character === "-" && sql[index + 1] === "-") {
+      let end = sql.indexOf("\n", index);
+      end = end === -1 ? sql.length : end;
+      output += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    if (character === "/" && sql[index + 1] === "*") {
+      let end = sql.indexOf("*/", index + 2);
+      end = end === -1 ? sql.length : end + 2;
+      output += " ".repeat(end - index);
+      index = end;
+      continue;
+    }
+    output += character;
+    index++;
+  }
+  return output;
+}
+function declaresAutoincrement(sql) {
+  return /\bAUTOINCREMENT\b/i.test(maskSqlLiterals(sql));
+}
+function parseTableOptions(sql) {
+  const masked = maskSqlLiterals(sql);
+  const close = masked.lastIndexOf(")");
+  const tail = close === -1 ? "" : masked.slice(close + 1);
+  return {
+    withoutRowid: /\bWITHOUT\s+ROWID\b/i.test(tail),
+    strict: /\bSTRICT\b/i.test(tail)
+  };
+}
+function parseVirtualTableModule(sql) {
+  const masked = maskSqlLiterals(sql);
+  const match = /\bUSING\s+([A-Za-z0-9_$\u0080-\uffff]+)/i.exec(masked);
+  return match ? sql.slice(match.index, match.index + match[0].length).replace(/^USING\s+/i, "") : void 0;
+}
+
+// src/introspection/introspect.ts
+async function introspectSqlite(connection, options, signal) {
+  const schemaName = options?.schemaName ?? "main";
+  const version = await detectSqliteVersion(connection, signal);
+  const capabilities = detectSqliteCapabilities(version);
+  const diagnostics = [];
+  const catalog = new CatalogReader(connection, schemaName, capabilities, signal);
+  const schemaRows = await catalog.schemaRows();
+  if (schemaRows === null) {
+    throw new SqliteDumperError(
+      "schema-not-found",
+      `No database named ${JSON.stringify(schemaName)} is attached to this connection`
+    );
+  }
+  const tableList = await catalog.tableList();
+  const virtualTableNames = schemaRows.filter((row) => row.type === "table" && isVirtualTableSql(row.sql)).map((row) => row.name);
+  const tables = [];
+  const indexes = [];
+  const foreignKeys = [];
+  const indexRowsByName = new Map(
+    schemaRows.filter((row) => row.type === "index").map((row) => [toAsciiLowerCase(row.name), row])
+  );
+  for (const row of schemaRows) {
+    throwIfAborted2(signal);
+    if (row.type !== "table" || row.sql === null) {
+      continue;
+    }
+    const listed = tableList?.get(toAsciiLowerCase(row.name));
+    const kind = classifyTable(row, listed?.type, virtualTableNames);
+    let columns = [];
+    try {
+      columns = await catalog.columns(row.name);
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      diagnostics.push({
+        severity: kind === "virtual" ? "warning" : "error",
+        code: kind === "virtual" ? "virtual-table-module-unavailable" : "table-columns-unreadable",
+        message: kind === "virtual" ? `The columns of virtual table "${row.name}" cannot be read, most likely because its module is not available in this SQLite build (${errorMessage(error)}). Its definition and its shadow tables are still dumped, which is all a restore needs.` : `The columns of table "${row.name}" cannot be read: ${errorMessage(error)}`,
+        objectReference: {
+          kind: kind === "virtual" ? "virtualTable" : "table",
+          schemaName,
+          name: row.name
+        }
+      });
+    }
+    const parsedOptions = parseTableOptions(row.sql);
+    const withoutRowid = listed ? listed.withoutRowid : kind === "table" || kind === "shadow" ? parsedOptions.withoutRowid : false;
+    const strict = listed ? listed.strict : parsedOptions.strict;
+    let tableIndexes = [];
+    let tableForeignKeys = [];
+    if (kind !== "virtual") {
+      tableIndexes = await catalog.indexes(row.name, indexRowsByName);
+      tableForeignKeys = await catalog.foreignKeys(row.name);
+    }
+    indexes.push(...tableIndexes);
+    foreignKeys.push(...tableForeignKeys);
+    const virtualModule = kind === "virtual" ? parseVirtualTableModule(row.sql) : void 0;
+    const ownerVirtualTable = kind === "shadow" ? findOwner(row.name, virtualTableNames) : void 0;
+    tables.push({
+      name: row.name,
+      kind,
+      schemaRowid: row.schemaRowid,
+      sql: row.sql,
+      withoutRowid,
+      strict,
+      hasAutoincrement: kind === "table" && declaresAutoincrement(row.sql),
+      ...virtualModule === void 0 ? {} : { virtualModule },
+      ...ownerVirtualTable === void 0 ? {} : { ownerVirtualTable },
+      rowidAliasColumn: kind === "virtual" || withoutRowid ? null : findRowidAlias(columns, tableIndexes),
+      columns
+    });
+  }
+  const seenIndexes = new Set(indexes.map((index) => toAsciiLowerCase(index.name)));
+  for (const row of schemaRows) {
+    if (row.type === "index" && row.sql !== null && !seenIndexes.has(toAsciiLowerCase(row.name))) {
+      indexes.push({
+        name: row.name,
+        tableName: row.tableName,
+        schemaRowid: row.schemaRowid,
+        sql: row.sql,
+        isUnique: /^CREATE\s+UNIQUE\b/i.test(row.sql),
+        origin: "c",
+        isPartial: false,
+        columns: []
+      });
+    }
+  }
+  indexes.sort((a, b) => a.schemaRowid - b.schemaRowid);
+  const views = schemaRows.filter((row) => row.type === "view" && row.sql !== null).map((row) => ({ name: row.name, schemaRowid: row.schemaRowid, sql: row.sql }));
+  const triggers = schemaRows.filter((row) => row.type === "trigger" && row.sql !== null).map((row) => ({
+    name: row.name,
+    tableName: row.tableName,
+    schemaRowid: row.schemaRowid,
+    sql: row.sql
+  }));
+  const sequences = tables.some((table) => table.name === "sqlite_sequence") ? await catalog.sequences() : [];
+  const settings = await catalog.settings();
+  return {
+    database: {
+      schemaName,
+      ...settings,
+      tables,
+      indexes,
+      views,
+      triggers,
+      foreignKeys,
+      sequences
+    },
+    version,
+    capabilities,
+    diagnostics
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isVirtualTableSql(sql) {
+  return sql !== null && sql.startsWith("CREATE VIRTUAL TABLE");
+}
+function classifyTable(row, listedType, virtualTableNames) {
+  if (row.name.startsWith("sqlite_")) {
+    return "system";
+  }
+  if (isVirtualTableSql(row.sql)) {
+    return "virtual";
+  }
+  if (listedType !== void 0) {
+    return listedType === "shadow" ? "shadow" : "table";
+  }
+  return findOwner(row.name, virtualTableNames) === void 0 ? "table" : "shadow";
+}
+function findOwner(tableName, virtualTableNames) {
+  const lower = toAsciiLowerCase(tableName);
+  let owner;
+  for (const name of virtualTableNames) {
+    const prefix = `${toAsciiLowerCase(name)}_`;
+    if (lower.startsWith(prefix) && lower.length > prefix.length) {
+      if (owner === void 0 || name.length > owner.length) {
+        owner = name;
+      }
+    }
+  }
+  return owner;
+}
+function findRowidAlias(columns, indexes) {
+  const primaryKey = columns.filter((column2) => column2.primaryKeyPosition > 0);
+  if (primaryKey.length !== 1) {
+    return null;
+  }
+  const column = primaryKey[0];
+  if (toAsciiUpperCase(column.declaredType) !== "INTEGER") {
+    return null;
+  }
+  if (indexes.some((index) => index.origin === "pk")) {
+    return null;
+  }
+  return column.name;
+}
+var CatalogReader = class {
+  constructor(connection, schemaName, capabilities, signal) {
+    this.connection = connection;
+    this.schemaName = schemaName;
+    this.capabilities = capabilities;
+    this.signal = signal;
+    this.qualifier = quoteIdentifier(schemaName);
+  }
+  connection;
+  schemaName;
+  capabilities;
+  signal;
+  qualifier;
+  async rows(sql, parameters) {
+    const result = await this.connection.query(
+      parameters === void 0 ? { sql } : { sql, parameters },
+      this.signal
+    );
+    return result.rows;
+  }
+  /** Runs `PRAGMA schema.name(argument)`, as a table-valued function when the library has them. */
+  async pragma(name, argument, columns) {
+    if (this.capabilities.supportsPragmaFunctions) {
+      return this.rows(`SELECT ${columns} FROM pragma_${name}(?, ?)`, [argument, this.schemaName]);
+    }
+    return this.rows(`PRAGMA ${this.qualifier}.${name}(${quoteStringLiteral(argument)})`);
+  }
+  async schemaRows() {
+    const databases = await this.rows("PRAGMA database_list");
+    const known = databases.some(
+      (row) => toAsciiLowerCase(toText(row.name) ?? "") === toAsciiLowerCase(this.schemaName)
+    );
+    if (!known) {
+      return null;
+    }
+    const master = toAsciiLowerCase(this.schemaName) === "temp" ? "sqlite_temp_master" : "sqlite_master";
+    const rows = await this.rows(
+      `SELECT rowid AS schemaRowid, type, name, tbl_name AS tableName, sql FROM ${this.qualifier}.${master} ORDER BY rowid`
+    );
+    return rows.map((row) => ({
+      schemaRowid: toNumber(row.schemaRowid),
+      type: toText(row.type) ?? "",
+      name: toText(row.name) ?? "",
+      tableName: toText(row.tableName) ?? "",
+      sql: toText(row.sql)
+    }));
+  }
+  async tableList() {
+    if (!this.capabilities.supportsTableList) {
+      return void 0;
+    }
+    try {
+      const rows = await this.rows(
+        "SELECT name, type, wr, strict FROM pragma_table_list WHERE schema = ?",
+        [this.schemaName]
+      );
+      return new Map(
+        rows.map((row) => [
+          toAsciiLowerCase(toText(row.name) ?? ""),
+          {
+            type: toText(row.type) ?? "table",
+            withoutRowid: toNumber(row.wr) !== 0,
+            strict: toNumber(row.strict) !== 0
+          }
+        ])
+      );
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      return void 0;
+    }
+  }
+  async columns(tableName) {
+    const withHidden = this.capabilities.supportsTableXinfo;
+    const rows = await this.pragma(
+      withHidden ? "table_xinfo" : "table_info",
+      tableName,
+      `cid, name, type, "notnull" AS isNotNull, dflt_value AS defaultValue, pk${withHidden ? ", hidden" : ""}`
+    );
+    return rows.map((row) => {
+      const hidden = withHidden ? toNumber(row.hidden) : 0;
+      return {
+        cid: toNumber(row.cid),
+        name: toText(row.name) ?? "",
+        declaredType: toText(row.type) ?? "",
+        notNull: toNumber(row.isNotNull ?? row.notnull) !== 0,
+        defaultValue: toText(row.defaultValue ?? row.dflt_value),
+        primaryKeyPosition: toNumber(row.pk),
+        hidden,
+        generated: hidden === 2 ? "virtual" : hidden === 3 ? "stored" : "none"
+      };
+    });
+  }
+  async indexes(tableName, schemaRows) {
+    const list = await this.pragma(
+      "index_list",
+      tableName,
+      'seq, name, "unique" AS isUnique, origin, partial'
+    );
+    const result = [];
+    for (const row of list) {
+      const name = toText(row.name) ?? "";
+      const schemaRow = schemaRows.get(toAsciiLowerCase(name));
+      const origin = toText(row.origin) ?? "c";
+      let columns = [];
+      try {
+        const keyRows = await this.pragma(
+          "index_xinfo",
+          name,
+          'seqno, cid, name, "desc" AS isDesc, coll, "key" AS isKey'
+        );
+        columns = keyRows.filter((keyRow) => toNumber(keyRow.isKey ?? keyRow.key) !== 0).map((keyRow) => ({
+          name: toText(keyRow.name),
+          cid: toNumber(keyRow.cid),
+          descending: toNumber(keyRow.isDesc ?? keyRow.desc) !== 0,
+          collation: toText(keyRow.coll)
+        }));
+      } catch (error) {
+        if (isAbortError(error)) throw error;
+      }
+      result.push({
+        name,
+        tableName,
+        // A WITHOUT ROWID table's primary-key index is the table itself and
+        // has no sqlite_schema row; it sorts with its table.
+        schemaRowid: schemaRow?.schemaRowid ?? 0,
+        sql: schemaRow?.sql ?? null,
+        isUnique: toNumber(row.isUnique ?? row.unique) !== 0,
+        origin: origin === "u" || origin === "pk" ? origin : "c",
+        isPartial: toNumber(row.partial) !== 0,
+        columns
+      });
+    }
+    return result;
+  }
+  async foreignKeys(tableName) {
+    const rows = await this.pragma(
+      "foreign_key_list",
+      tableName,
+      'id, seq, "table" AS referencedTable, "from" AS fromColumn, "to" AS toColumn, on_update AS onUpdate, on_delete AS onDelete, "match" AS matchMode'
+    );
+    const byId = /* @__PURE__ */ new Map();
+    const ordered = [...rows].sort(
+      (a, b) => toNumber(a.id) - toNumber(b.id) || toNumber(a.seq) - toNumber(b.seq)
+    );
+    for (const row of ordered) {
+      const id = toNumber(row.id);
+      let foreignKey = byId.get(id);
+      if (!foreignKey) {
+        foreignKey = {
+          tableName,
+          id,
+          referencedTableName: toText(row.referencedTable ?? row.table) ?? "",
+          columns: [],
+          onUpdate: toText(row.onUpdate ?? row.on_update) ?? "NO ACTION",
+          onDelete: toText(row.onDelete ?? row.on_delete) ?? "NO ACTION",
+          match: toText(row.matchMode ?? row.match) ?? "NONE"
+        };
+        byId.set(id, foreignKey);
+      }
+      foreignKey.columns.push({
+        from: toText(row.fromColumn ?? row.from) ?? "",
+        to: toText(row.toColumn ?? row.to)
+      });
+    }
+    return [...byId.values()];
+  }
+  async sequences() {
+    const rows = await this.rows(
+      `SELECT name, CAST(seq AS TEXT) AS value FROM ${this.qualifier}.sqlite_sequence`
+    );
+    return rows.map((row) => ({
+      tableName: toText(row.name) ?? "",
+      value: toText(row.value) ?? "0"
+    }));
+  }
+  async settings() {
+    const read = async (pragma) => {
+      try {
+        const rows = await this.rows(`PRAGMA ${this.qualifier}.${pragma}`);
+        const first = rows[0];
+        return first === void 0 ? void 0 : Object.values(first)[0];
+      } catch (error) {
+        if (isAbortError(error)) throw error;
+        return void 0;
+      }
+    };
+    let encoding;
+    try {
+      const rows = await this.rows("PRAGMA encoding");
+      encoding = rows[0] === void 0 ? void 0 : Object.values(rows[0])[0];
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+    }
+    const pageSize = await read("page_size");
+    return {
+      encoding: toText(encoding) ?? "UTF-8",
+      userVersion: toNumber(await read("user_version")),
+      applicationId: toNumber(await read("application_id")),
+      ...pageSize === void 0 ? {} : { pageSize: toNumber(pageSize) }
+    };
+  }
+};
+
+// src/renderer/types.ts
+function resolvePlainSqlRenderOptions(options) {
+  return {
+    includeSessionGuards: options?.includeSessionGuards ?? true,
+    includeHeaderComments: options?.includeHeaderComments ?? true,
+    addDropStatements: options?.addDropStatements ?? false,
+    includeDatabaseSettings: options?.includeDatabaseSettings ?? false,
+    legacySchemaTableName: options?.legacySchemaTableName ?? false,
+    unsupportedFeaturePolicy: options?.unsupportedFeaturePolicy ?? "error"
+  };
+}
+
+// src/restore/complete.ts
+var CompleteToken = {
+  Semi: 0,
+  Whitespace: 1,
+  Other: 2,
+  Explain: 3,
+  Create: 4,
+  Temp: 5,
+  Trigger: 6,
+  End: 7
+};
+var COMPLETE_TRANSITIONS = [
+  //         SEMI  WS  OTHER EXPLAIN CREATE TEMP TRIGGER END
+  /* 0 */
+  [1, 0, 2, 3, 4, 2, 2, 2],
+  /* 1 */
+  [1, 1, 2, 3, 4, 2, 2, 2],
+  /* 2 */
+  [1, 2, 2, 2, 2, 2, 2, 2],
+  /* 3 */
+  [1, 3, 3, 2, 4, 2, 2, 2],
+  /* 4 */
+  [1, 4, 2, 2, 2, 4, 5, 2],
+  /* 5 */
+  [6, 5, 5, 5, 5, 5, 5, 5],
+  /* 6 */
+  [6, 6, 5, 5, 5, 5, 5, 7],
+  /* 7 */
+  [1, 7, 5, 5, 5, 5, 5, 5]
+];
+function completeTransition(state, token) {
+  return COMPLETE_TRANSITIONS[state][token];
+}
+function isIdentifierCharCode(code) {
+  return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95 || code === 36 || code >= 128;
+}
+function classifyWord(word) {
+  switch (word.length) {
+    case 3:
+      return word.toLowerCase() === "end" ? CompleteToken.End : CompleteToken.Other;
+    case 4:
+      return word.toLowerCase() === "temp" ? CompleteToken.Temp : CompleteToken.Other;
+    case 6:
+      return word.toLowerCase() === "create" ? CompleteToken.Create : CompleteToken.Other;
+    case 7: {
+      const lower = word.toLowerCase();
+      if (lower === "trigger") return CompleteToken.Trigger;
+      if (lower === "explain") return CompleteToken.Explain;
+      return CompleteToken.Other;
+    }
+    case 9:
+      return word.toLowerCase() === "temporary" ? CompleteToken.Temp : CompleteToken.Other;
+    default:
+      return CompleteToken.Other;
+  }
+}
+function isCompleteWhitespace(character) {
+  return character === " " || character === "\r" || character === "	" || character === "\n" || character === "\f";
+}
+function isCompleteStatement(sql) {
+  let state = 0;
+  let index = 0;
+  const length = sql.length;
+  while (index < length) {
+    const character = sql[index];
+    let token;
+    if (character === ";") {
+      token = CompleteToken.Semi;
+    } else if (isCompleteWhitespace(character)) {
+      token = CompleteToken.Whitespace;
+    } else if (character === "/") {
+      if (sql[index + 1] !== "*") {
+        token = CompleteToken.Other;
+      } else {
+        index += 2;
+        while (index < length && !(sql[index] === "*" && sql[index + 1] === "/")) {
+          index++;
+        }
+        if (index >= length) {
+          return false;
+        }
+        index++;
+        token = CompleteToken.Whitespace;
+      }
+    } else if (character === "-") {
+      if (sql[index + 1] !== "-") {
+        token = CompleteToken.Other;
+      } else {
+        while (index < length && sql[index] !== "\n") {
+          index++;
+        }
+        if (index >= length) {
+          return state === 1;
+        }
+        token = CompleteToken.Whitespace;
+      }
+    } else if (character === "[") {
+      index++;
+      while (index < length && sql[index] !== "]") {
+        index++;
+      }
+      if (index >= length) {
+        return false;
+      }
+      token = CompleteToken.Other;
+    } else if (character === "`" || character === '"' || character === "'") {
+      index++;
+      while (index < length && sql[index] !== character) {
+        index++;
+      }
+      if (index >= length) {
+        return false;
+      }
+      token = CompleteToken.Other;
+    } else if (isIdentifierCharCode(sql.charCodeAt(index))) {
+      let end = index + 1;
+      while (end < length && isIdentifierCharCode(sql.charCodeAt(end))) {
+        end++;
+      }
+      token = classifyWord(sql.slice(index, end));
+      index = end - 1;
+    } else {
+      token = CompleteToken.Other;
+    }
+    state = completeTransition(state, token);
+    index++;
+  }
+  return state === 1;
+}
+
+// src/renderer/objectRenderers.ts
+var SESSION_GUARD_HEADER = "PRAGMA foreign_keys=OFF;\nBEGIN TRANSACTION;\n";
+var SESSION_GUARD_FOOTER = "COMMIT;\n";
+var WRITABLE_SCHEMA_ON = "PRAGMA writable_schema=ON;\n";
+var WRITABLE_SCHEMA_OFF = "PRAGMA writable_schema=OFF;\n";
+function renderSchemaLine(sql, tail = ";\n") {
+  let text = sql;
+  if (tail.startsWith(";") && (text.includes("/*") || text.includes("--"))) {
+    for (const terminator of ["", "*/", "\n"]) {
+      if (isCompleteStatement(`${text}${terminator};`)) {
+        text = `${text}${terminator}`;
+        break;
+      }
+    }
+  }
+  if (/^CREATE TABLE ['"]/.test(text)) {
+    return `CREATE TABLE IF NOT EXISTS ${text.slice(13)}${tail}`;
+  }
+  return `${text}${tail}`;
+}
+function renderSchemaObject(sql) {
+  return sql.includes("--") ? `${sql}
+;
+` : `${sql};
+`;
+}
+function renderVirtualTable(name, sql, schemaTableName) {
+  const quotedName = quoteStringLiteral(name);
+  return `INSERT INTO ${schemaTableName}(type,name,tbl_name,rootpage,sql)VALUES('table',${quotedName},${quotedName},0,${quoteStringLiteral(sql)});
+`;
+}
+function renderSystemTablePrelude(name, schemaTableName, systemRowFilter) {
+  if (name === "sqlite_sequence") {
+    if (systemRowFilter === void 0) {
+      return "DELETE FROM sqlite_sequence;\n";
+    }
+    const names = [...new Set(systemRowFilter.map(toAsciiLowerCase))].map(quoteStringLiteral);
+    return `DELETE FROM sqlite_sequence WHERE lower(name) IN (${names.join(",")});
+`;
+  }
+  return `ANALYZE ${schemaTableName};
+`;
+}
+function renderDrop(kind, name) {
+  return `DROP ${kind} IF EXISTS ${quoteIdentifierIfNeeded(name)};
+`;
+}
+function renderDatabaseSettings(userVersion, applicationId) {
+  let text = "";
+  if (userVersion !== 0) {
+    text += `PRAGMA user_version=${userVersion};
+`;
+  }
+  if (applicationId !== 0) {
+    text += `PRAGMA application_id=${applicationId};
+`;
+  }
+  return text;
+}
+
+// src/restore/preview.ts
+function safeSqlPreview(sql, maximumLength = 200) {
+  const normalized = redactSecrets(sql).trim().replace(/\s+/g, " ");
+  if (normalized.length <= maximumLength) {
+    return normalized;
+  }
+  let cut = normalized.slice(0, maximumLength);
+  const lastUnit = cut.charCodeAt(cut.length - 1);
+  if (lastUnit >= 55296 && lastUnit <= 56319) {
+    cut = cut.slice(0, -1);
+  }
+  return `${cut}\u2026`;
+}
+var DEFENSIVE_WARNING_COMMENT = "/* WARNING: Script requires that SQLITE_DBCONFIG_DEFENSIVE be disabled */";
+function isSqliteDump(sample) {
+  const text = typeof sample === "string" ? sample : Buffer.from(sample).toString("utf8");
+  const head = text.slice(0, 8192).replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  let rest = head.trimStart();
+  if (rest.startsWith(DEFENSIVE_WARNING_COMMENT)) {
+    rest = rest.slice(DEFENSIVE_WARNING_COMMENT.length).trimStart();
+    if (rest === "" || /^INSERT INTO /.test(rest) || rest.startsWith("PRAGMA foreign_keys=OFF;")) {
+      return true;
+    }
+  }
+  return /^PRAGMA foreign_keys=OFF;\s*\nBEGIN TRANSACTION;/.test(rest);
+}
+
+// src/renderer/plainSql.ts
+var SECTION_BY_ENTRY = {
+  table: "table-structure",
+  tableData: "table-data",
+  virtualTable: "virtual-table",
+  index: "index",
+  trigger: "trigger",
+  view: "view"
+};
+async function renderPlainSql(request) {
+  const options = resolvePlainSqlRenderOptions(request.options);
+  const { database, archive, writer, signal, onProgress, onTableData } = request;
+  const mode = request.mode ?? "full";
+  if (!archive.valid) {
+    throw new SqliteDumperError(
+      "invalid-archive",
+      "Cannot render an archive inspection that failed validation; see archive.diagnostics, archive.cycles and archive.unsatisfiedDependencies"
+    );
+  }
+  const warnings = [];
+  const renderedDumpIds = [];
+  const skippedDumpIds = [];
+  const schemaTableName = options.legacySchemaTableName ? "sqlite_master" : "sqlite_schema";
+  const tables = new Map(database.tables.map((table) => [foldSqliteName(table.name), table]));
+  const indexes = new Map(database.indexes.map((index) => [foldSqliteName(index.name), index]));
+  const triggers = new Map(
+    database.triggers.map((trigger) => [foldSqliteName(trigger.name), trigger])
+  );
+  const views = new Map(database.views.map((view) => [foldSqliteName(view.name), view]));
+  const emit = async (text) => {
+    if (text !== "") {
+      await writer.write(text, signal);
+    }
+  };
+  const guards = options.includeSessionGuards && mode !== "data-only";
+  if (!options.includeSessionGuards && mode !== "data-only") {
+    warnings.push({
+      severity: "warning",
+      code: "session-guards-disabled",
+      message: "render.includeSessionGuards is false, so the dump omits PRAGMA foreign_keys=OFF and its BEGIN TRANSACTION / COMMIT. Tables that reference each other may fail to restore in the emitted order, and every INSERT runs as its own transaction, which makes restoring a large dump dramatically slower."
+    });
+  }
+  reportUnDumpedSettings(request, options, warnings);
+  const containsVirtualTables = mode !== "schema-only" && archive.entries.some(
+    (entry) => entry.objectType === "virtualTable" || entry.tableKind === "virtual" || entry.tableKind === "shadow" && tables.get(foldSqliteName(entry.name))?.ownerVirtualTable !== void 0
+  );
+  let writableSchema = false;
+  try {
+    if (options.includeHeaderComments && containsVirtualTables) {
+      await emit(`${DEFENSIVE_WARNING_COMMENT}
+`);
+    }
+    if (guards) {
+      await emit(SESSION_GUARD_HEADER);
+    }
+    let processed = 0;
+    const total = archive.entries.length;
+    for (const entry of archive.entries) {
+      throwIfAborted2(signal);
+      processed++;
+      onProgress?.({
+        phase: "rendering-schema",
+        section: SECTION_BY_ENTRY[entry.objectType],
+        objectsProcessed: processed,
+        objectsTotal: total,
+        objectName: entry.name,
+        schemaName: entry.schemaName,
+        bytesWritten: writer.bytesWritten
+      });
+      let handled;
+      switch (entry.objectType) {
+        case "table": {
+          const table = tables.get(foldSqliteName(entry.name));
+          if (!table) {
+            handled = missing(entry, "table", warnings, options);
+            break;
+          }
+          if (table.kind === "system") {
+            await emit(
+              renderSystemTablePrelude(table.name, schemaTableName, entry.systemRowFilter)
+            );
+          } else {
+            if (options.addDropStatements) {
+              await emit(renderDrop("TABLE", table.name));
+            }
+            await emit(renderSchemaLine(table.sql));
+          }
+          handled = true;
+          break;
+        }
+        case "virtualTable": {
+          const table = tables.get(foldSqliteName(entry.name));
+          if (!table) {
+            handled = missing(entry, "virtual table", warnings, options);
+            break;
+          }
+          if (options.addDropStatements) {
+            await emit(renderDrop("TABLE", table.name));
+          }
+          if (mode === "schema-only") {
+            await emit(renderSchemaLine(table.sql));
+          } else {
+            if (!writableSchema) {
+              await emit(WRITABLE_SCHEMA_ON);
+              writableSchema = true;
+            }
+            await emit(renderVirtualTable(table.name, table.sql, schemaTableName));
+          }
+          handled = true;
+          break;
+        }
+        case "tableData": {
+          const table = tables.get(foldSqliteName(entry.name));
+          if (!table) {
+            handled = missing(entry, "table", warnings, options);
+            break;
+          }
+          if (onTableData) {
+            handled = await onTableData(entry);
+          } else {
+            warnings.push({
+              severity: "warning",
+              code: "data-not-rendered",
+              message: `Row data for table "${entry.name}" was selected, but renderPlainSql only renders schema objects; use dumpSqlite (or supply onTableData) with a live connection to stream rows.`,
+              objectReference: { kind: "table", schemaName: entry.schemaName, name: entry.name }
+            });
+            handled = true;
+          }
+          break;
+        }
+        case "index":
+        case "trigger":
+        case "view": {
+          const object = lookupSchemaObject(entry, indexes, triggers, views);
+          if (!object || object.sql === null) {
+            handled = missing(entry, entry.objectType, warnings, options);
+            break;
+          }
+          if (options.addDropStatements) {
+            await emit(
+              renderDrop(
+                entry.objectType === "index" ? "INDEX" : entry.objectType === "trigger" ? "TRIGGER" : "VIEW",
+                entry.name
+              )
+            );
+          }
+          await emit(renderSchemaObject(object.sql));
+          handled = true;
+          break;
+        }
+        default: {
+          const unreachable = entry.objectType;
+          throw new SqliteDumperError(
+            "unsupported-object",
+            `Unhandled archive object type: ${String(unreachable)}`
+          );
+        }
+      }
+      if (handled) {
+        renderedDumpIds.push(entry.dumpId);
+      } else {
+        skippedDumpIds.push(entry.dumpId);
+      }
+    }
+    if (writableSchema) {
+      await emit(WRITABLE_SCHEMA_OFF);
+    }
+    if (options.includeDatabaseSettings) {
+      await emit(renderDatabaseSettings(database.userVersion, database.applicationId));
+    }
+    if (guards) {
+      await emit(SESSION_GUARD_FOOTER);
+    }
+    return {
+      bytesWritten: writer.bytesWritten,
+      renderedDumpIds,
+      skippedDumpIds,
+      warnings,
+      cancelled: false
+    };
+  } catch (error) {
+    if (isAbortError(error)) {
+      return {
+        bytesWritten: writer.bytesWritten,
+        renderedDumpIds,
+        skippedDumpIds,
+        warnings,
+        cancelled: true
+      };
+    }
+    throw error;
+  }
+}
+function lookupSchemaObject(entry, indexes, triggers, views) {
+  const key = foldSqliteName(entry.name);
+  switch (entry.objectType) {
+    case "index":
+      return indexes.get(key);
+    case "trigger":
+      return triggers.get(key);
+    default:
+      return views.get(key);
+  }
+}
+function reportUnDumpedSettings(request, options, warnings) {
+  if (options.includeDatabaseSettings) {
+    return;
+  }
+  const { database } = request;
+  if (database.userVersion !== 0) {
+    warnings.push({
+      severity: "warning",
+      code: "user-version-not-dumped",
+      message: `The database's PRAGMA user_version is ${database.userVersion}, which the dump does not carry (the native .dump does not either). Set render.includeDatabaseSettings to include it; applications often track schema migrations in it.`,
+      objectReference: {
+        kind: "database",
+        schemaName: database.schemaName,
+        name: database.schemaName
+      }
+    });
+  }
+  if (database.applicationId !== 0) {
+    warnings.push({
+      severity: "warning",
+      code: "application-id-not-dumped",
+      message: `The database's PRAGMA application_id is ${database.applicationId}, which the dump does not carry (the native .dump does not either). Set render.includeDatabaseSettings to include it.`,
+      objectReference: {
+        kind: "database",
+        schemaName: database.schemaName,
+        name: database.schemaName
+      }
+    });
+  }
+}
+function missing(entry, kind, warnings, options) {
+  const message = `Archive entry references ${kind} "${entry.name}", which was not found in the introspected model`;
+  if (options.unsupportedFeaturePolicy === "warn-omit") {
+    warnings.push({ severity: "warning", code: "model-object-missing", message });
+    return false;
+  }
+  throw new SqliteDumperError("model-object-missing", message);
+}
+
+// src/data/chunkBuilder.ts
+var SqlChunkBuilder = class {
+  parts = [];
+  byteLength = 0;
+  hasBytes = false;
+  /** UTF-8 byte length of everything appended so far. */
+  get length() {
+    return this.byteLength;
+  }
+  get isEmpty() {
+    return this.parts.length === 0;
+  }
+  append(part) {
+    if (typeof part === "string") {
+      if (part.length === 0) {
+        return this;
+      }
+      this.parts.push(part);
+      this.byteLength += Buffer.byteLength(part, "utf8");
+      return this;
+    }
+    if (part.length === 0) {
+      return this;
+    }
+    this.parts.push(part);
+    this.byteLength += part.length;
+    this.hasBytes = true;
+    return this;
+  }
+  /** Appends everything from `other`, leaving `other` untouched. */
+  appendBuilder(other) {
+    for (const part of other.parts) {
+      this.append(part);
+    }
+    return this;
+  }
+  /** The accumulated content, as a `string` when it is all text and a `Buffer` otherwise. */
+  build() {
+    if (!this.hasBytes) {
+      return this.parts.join("");
+    }
+    return Buffer.concat(
+      this.parts.map((part) => typeof part === "string" ? Buffer.from(part, "utf8") : part)
+    );
+  }
+};
+
+// src/data/valueQuery.ts
+var import_node_buffer = require("buffer");
+function realLiteralExpression(column) {
+  return `CASE WHEN ${column} = 9e999 THEN '9.0e+999' WHEN ${column} = -9e999 THEN '-9.0e+999' WHEN ${column} >= -9223372036854775808.0 AND ${column} < 9223372036854775808.0 AND ${column} = CAST(${column} AS INTEGER) THEN CAST(CAST(${column} AS INTEGER) AS TEXT) || '.0' ELSE printf('%!.20g', ${column}) END`;
+}
+function columnValueSelect(column, index, utf8Database) {
+  const textBranch = utf8Database ? `CAST(${column} AS BLOB)` : column;
+  return `typeof(${column}) AS "t${index}", CASE typeof(${column}) WHEN 'integer' THEN CAST(${column} AS TEXT) WHEN 'real' THEN ${realLiteralExpression(column)} WHEN 'text' THEN ${textBranch} ELSE ${column} END AS "v${index}"`;
+}
+function asBytes(value) {
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return Buffer.from(String(value), "utf8");
+}
+function renderColumnLiteral(row, index, textStyle) {
+  const storageClass = row[`t${index}`];
+  const value = row[`v${index}`] ?? null;
+  switch (storageClass) {
+    case "integer":
+    case "real":
+      return String(value);
+    case "text": {
+      if (typeof value === "string") {
+        return renderTextLiteral(value, textStyle);
+      }
+      const bytes = asBytes(value);
+      if ((0, import_node_buffer.isUtf8)(bytes)) {
+        return renderTextLiteral(bytes.toString("utf8"), textStyle);
+      }
+      return Buffer.from(renderTextLiteral(bytes.toString("latin1"), textStyle), "latin1");
+    }
+    case "blob":
+      return renderBlobLiteral(asBytes(value));
+    default:
+      return "NULL";
+  }
+}
+
+// src/data/insertExport.ts
+var DEFAULT_MAX_STATEMENT_BYTES = 1024 * 1024;
+var DEFAULT_MAX_ROWS_PER_STATEMENT = 500;
+var OUTPUT_CHUNK_BYTES = 64 * 1024;
+var ROWID_NAMES = ["rowid", "_rowid_", "oid"];
+function insertableColumns(table) {
+  return [...table.columns].sort((a, b) => a.cid - b.cid).filter((column) => column.hidden === 0);
+}
+function preservableRowidName(table) {
+  if (table.withoutRowid || table.rowidAliasColumn !== null || table.kind === "virtual") {
+    return null;
+  }
+  const names = new Set(insertableColumns(table).map((column) => toAsciiLowerCase(column.name)));
+  for (const candidate of ROWID_NAMES) {
+    if (!names.has(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function exportTableDataAsInserts(request) {
+  const { connection, schemaName, table, writer, signal, onProgress } = request;
+  const options = request.options ?? {};
+  const extendedInsert = options.extendedInsert ?? false;
+  const maxRowsPerStatement = extendedInsert ? Math.max(1, options.maxRowsPerStatement ?? DEFAULT_MAX_ROWS_PER_STATEMENT) : 1;
+  const maxStatementBytes = Math.max(
+    1024,
+    options.maxStatementBytes ?? DEFAULT_MAX_STATEMENT_BYTES
+  );
+  const textStyle = options.rawNewlines ? "raw-newlines" : "escaped";
+  const utf8Database = (request.encoding ?? "UTF-8").toUpperCase() === "UTF-8";
+  const warnings = [];
+  const columns = insertableColumns(table);
+  const rowidName = options.preserveRowids ? preservableRowidName(table) : null;
+  for (const column of table.columns) {
+    if (column.generated !== "none") {
+      warnings.push({
+        severity: "info",
+        code: "generated-column-not-exported",
+        message: `Column "${table.name}"."${column.name}" is a ${column.generated.toUpperCase()} generated column; SQLite derives its value, so it is excluded from INSERT and recomputed on restore.`,
+        objectReference: { kind: "column", schemaName, name: column.name, parentName: table.name }
+      });
+    }
+  }
+  if (columns.length === 0) {
+    warnings.push({
+      severity: "warning",
+      code: "table-has-no-insertable-columns",
+      message: `Table "${table.name}" has no insertable columns, so no row data is dumped for it.`,
+      objectReference: { kind: "table", schemaName, name: table.name }
+    });
+    return {
+      rowsExported: 0,
+      bytesWritten: writer.bytesWritten,
+      statementsWritten: 0,
+      cancelled: false,
+      warnings
+    };
+  }
+  const columnList = rowidName ? `(${[rowidName, ...columns.map((column) => quoteIdentifierIfNeeded(column.name))].join(",")})` : "";
+  const statementPrefix = `INSERT INTO ${quoteIdentifierIfNeeded(table.name)}${columnList} VALUES`;
+  const selectList = [
+    ...rowidName ? [columnValueSelect(rowidName, 0, utf8Database)] : [],
+    ...columns.map(
+      (column, index) => columnValueSelect(quoteIdentifier(column.name), index + (rowidName ? 1 : 0), utf8Database)
+    )
+  ].join(", ");
+  const valueCount = columns.length + (rowidName ? 1 : 0);
+  const sql = `SELECT ${selectList} FROM ${quoteQualifiedIdentifier(schemaName, table.name)}${systemRowFilterClause(table, request.systemRowFilter)}`;
+  let rowsExported = 0;
+  let statementsWritten = 0;
+  let output = new SqlChunkBuilder();
+  let statement = null;
+  let statementRows = 0;
+  const flushOutput = async () => {
+    if (output.isEmpty) {
+      return;
+    }
+    const chunk = output.build();
+    output = new SqlChunkBuilder();
+    await writer.write(chunk, signal);
+  };
+  const closeStatement = async () => {
+    if (!statement || statementRows === 0) {
+      return;
+    }
+    statement.append(";\n");
+    output.appendBuilder(statement);
+    statement = null;
+    statementRows = 0;
+    statementsWritten++;
+    if (output.length >= OUTPUT_CHUNK_BYTES) {
+      await flushOutput();
+    }
+  };
+  const progress = (exportState) => {
+    onProgress?.({
+      phase: "exporting-data",
+      section: "table-data",
+      schemaName,
+      tableName: table.name,
+      objectName: table.name,
+      rowsExported,
+      bytesWritten: writer.bytesWritten,
+      exportState
+    });
+  };
+  progress("started");
+  try {
+    for await (const row of connection.stream(
+      { sql },
+      {
+        ...signal === void 0 ? {} : { signal },
+        ...options.streamBatchSize === void 0 ? {} : { batchSize: options.streamBatchSize }
+      }
+    )) {
+      throwIfAborted2(signal);
+      const tuple = new SqlChunkBuilder();
+      tuple.append("(");
+      for (let index = 0; index < valueCount; index++) {
+        if (index > 0) {
+          tuple.append(",");
+        }
+        tuple.append(renderColumnLiteral(row, index, textStyle));
+      }
+      tuple.append(")");
+      if (statement && (statementRows >= maxRowsPerStatement || statement.length + tuple.length + 2 > maxStatementBytes)) {
+        await closeStatement();
+      }
+      if (!statement) {
+        statement = new SqlChunkBuilder();
+        statement.append(statementPrefix);
+      } else {
+        statement.append(",");
+      }
+      statement.appendBuilder(tuple);
+      statementRows++;
+      rowsExported++;
+      if (rowsExported % 1e3 === 0) {
+        progress("progress");
+      }
+    }
+    await closeStatement();
+    await flushOutput();
+    progress("finished");
+    return {
+      rowsExported,
+      bytesWritten: writer.bytesWritten,
+      statementsWritten,
+      cancelled: false,
+      warnings
+    };
+  } catch (error) {
+    if (isAbortError(error)) {
+      progress("cancelled");
+      return {
+        rowsExported,
+        bytesWritten: writer.bytesWritten,
+        statementsWritten,
+        cancelled: true,
+        warnings
+      };
+    }
+    progress("failed");
+    throw error;
+  }
+}
+function systemRowFilterClause(table, filter) {
+  if (filter === void 0 || table.kind !== "system") {
+    return "";
+  }
+  const column = table.name === "sqlite_sequence" ? "name" : "tbl";
+  const names = [...new Set(filter.map(toAsciiLowerCase))].map(quoteStringLiteral);
+  if (names.length === 0) {
+    return " WHERE 0";
+  }
+  return ` WHERE lower(${column}) IN (${names.join(",")})`;
+}
+
+// src/compatibility/check.ts
+var FEATURE_LABELS = {
+  supportsWithoutRowid: "WITHOUT ROWID tables (SQLite 3.8.2+)",
+  supportsMultiRowValues: "multi-row VALUES (SQLite 3.7.11+)",
+  supportsPragmaFunctions: "table-valued pragma functions (SQLite 3.16.0+)",
+  supportsTableXinfo: "PRAGMA table_xinfo (SQLite 3.26.0+)",
+  supportsGeneratedColumns: "generated columns (SQLite 3.31.0+)",
+  supportsSqliteSchemaAlias: "the sqlite_schema table name (SQLite 3.33.0+)",
+  supportsWritableSchemaReset: "PRAGMA writable_schema=RESET (SQLite 3.35.0+)",
+  supportsStrictTables: "STRICT tables (SQLite 3.37.0+)",
+  supportsTableList: "PRAGMA table_list (SQLite 3.37.0+)"
+};
+var BUILT_IN_COLLATIONS = /* @__PURE__ */ new Set(["BINARY", "NOCASE", "RTRIM"]);
+function checkTargetCompatibility(database, target, options = {}) {
+  const diagnostics = [];
+  const { schemaName } = database;
+  const reported = /* @__PURE__ */ new Set();
+  const require2 = (feature, detail, objectReference) => {
+    if (target[feature] || reported.has(feature)) {
+      return;
+    }
+    reported.add(feature);
+    diagnostics.push({
+      severity: "error",
+      code: "unsupported-target-feature",
+      message: `Restore target does not support ${FEATURE_LABELS[feature]}, which this dump uses: ${detail}`,
+      ...objectReference === void 0 ? {} : { objectReference }
+    });
+  };
+  const missingModules = /* @__PURE__ */ new Set();
+  for (const table of database.tables) {
+    const reference = { kind: "table", schemaName, name: table.name };
+    if (table.strict) {
+      require2("supportsStrictTables", `table "${table.name}"`, reference);
+    }
+    if (table.withoutRowid) {
+      require2("supportsWithoutRowid", `table "${table.name}"`, reference);
+    }
+    for (const column of table.columns) {
+      if (column.generated !== "none") {
+        require2("supportsGeneratedColumns", `column "${table.name}"."${column.name}"`, {
+          kind: "column",
+          schemaName,
+          name: column.name,
+          parentName: table.name
+        });
+      }
+    }
+    if (table.kind === "virtual") {
+      if (!options.legacySchemaTableName) {
+        require2("supportsSqliteSchemaAlias", `virtual table "${table.name}" is recreated through INSERT INTO sqlite_schema`, reference);
+      }
+      const module2 = table.virtualModule === void 0 ? void 0 : toAsciiLowerCase(table.virtualModule);
+      if (options.modules && module2 !== void 0 && !options.modules.has(module2) && !missingModules.has(module2)) {
+        missingModules.add(module2);
+        diagnostics.push({
+          severity: "error",
+          code: "virtual-table-module-unavailable",
+          message: `Restore target has no "${table.virtualModule}" module, which virtual table "${table.name}" needs. The dump still restores \u2014 its schema row and shadow tables are plain SQL \u2014 but the table cannot be queried there until the module is loaded.`,
+          objectReference: { kind: "virtualTable", schemaName, name: table.name }
+        });
+      }
+    }
+    if (table.kind === "system" && /^sqlite_stat/.test(table.name) && !options.legacySchemaTableName) {
+      require2("supportsSqliteSchemaAlias", "the statistics tables are recreated by ANALYZE sqlite_schema", reference);
+    }
+  }
+  if (options.extendedInsert) {
+    require2("supportsMultiRowValues", "dataExport.extendedInsert is enabled");
+  }
+  const customCollations = /* @__PURE__ */ new Map();
+  for (const index of database.indexes) {
+    for (const column of index.columns) {
+      if (column.collation !== null && !BUILT_IN_COLLATIONS.has(toAsciiUpperCase(column.collation))) {
+        customCollations.set(toAsciiUpperCase(column.collation), index.name);
+      }
+    }
+  }
+  for (const [collation, indexName] of customCollations) {
+    diagnostics.push({
+      severity: "warning",
+      code: "custom-collation",
+      message: `Index "${indexName}" uses the collation ${collation}, which is not built into SQLite. The restoring application must register it (sqlite3_create_collation) before the restore, or the index cannot be created.`,
+      objectReference: { kind: "index", schemaName, name: indexName }
+    });
+  }
+  return diagnostics;
+}
+
+// src/compatibility/unsupported.ts
+var UNSUPPORTED_FEATURES = [
+  {
+    code: "file-settings-not-dumped",
+    summary: "file-level settings (page_size, auto_vacuum, journal_mode, encoding)",
+    detail: "These describe how the database file is laid out, not what it contains, and most can only be chosen before the first table is created. The native .dump does not carry them either. Set them on the target database before restoring if they matter; the dump restores correctly under any of them."
+  },
+  {
+    code: "temp-and-attached-schemas-not-dumped",
+    summary: "the temp schema and attached databases",
+    detail: "A dump covers one schema \u2014 main by default. Temporary objects belong to one connection, and each attached database is a separate file; dump an attached database on its own by passing its name as schemaName."
+  },
+  {
+    code: "application-functions-not-dumped",
+    summary: "application-defined functions, collations and loadable extensions",
+    detail: "User-defined SQL functions, collating sequences and virtual table modules are registered by the application (or loaded from a shared library), not stored in the database. The schema that uses them is dumped verbatim; the restoring application must register them first, or objects using them cannot be created or queried."
+  },
+  {
+    code: "encryption-not-dumped",
+    summary: "encryption keys",
+    detail: "An encrypted database (SQLCipher, SEE) is dumped as plain SQL once it is opened with its key. The dump itself is not encrypted, and no key is ever written into it."
+  }
+];
+function unsupportedFeatureDiagnostics() {
+  return UNSUPPORTED_FEATURES.map((feature) => ({
+    severity: "info",
+    code: feature.code,
+    message: `Not dumped: ${feature.summary}. ${feature.detail}`
+  }));
+}
+
+// src/preflight/preflightRestore.ts
+async function queryRows(connection, sql, signal) {
+  try {
+    return (await connection.query({ sql }, signal)).rows;
+  } catch (error) {
+    if (isAbortError(error)) throw error;
+    return void 0;
+  }
+}
+function firstValue(rows) {
+  const first = rows?.[0];
+  return first === void 0 ? void 0 : Object.values(first)[0];
+}
+async function preflightRestore(request) {
+  const acquired = await acquireSqliteConnection(request.connection, request.signal);
+  const connection = acquired.connection;
+  const { signal } = request;
+  try {
+    const version = await detectSqliteVersion(connection, signal);
+    const capabilities = detectSqliteCapabilities(version);
+    const encoding = toText(firstValue(await queryRows(connection, "PRAGMA encoding", signal))) ?? "UTF-8";
+    const foreignKeysEnabled = toNumber(firstValue(await queryRows(connection, "PRAGMA foreign_keys", signal))) !== 0;
+    const moduleRows = await queryRows(connection, "SELECT name FROM pragma_module_list", signal);
+    const optionRows = await queryRows(connection, "PRAGMA compile_options", signal);
+    const compileOptions = optionRows?.map((row) => toText(Object.values(row)[0]) ?? "");
+    const modules = moduleRows?.map((row) => toText(row.name) ?? "").filter((name) => name !== "");
+    const existingRows = await queryRows(
+      connection,
+      "SELECT type, name FROM main.sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY rowid",
+      signal
+    ) ?? [];
+    const existingObjects = existingRows.map((row) => ({
+      type: toText(row.type) ?? "",
+      name: toText(row.name) ?? ""
+    }));
+    const inTransaction = connection.isInTransaction?.();
+    const diagnostics = [];
+    if (inTransaction) {
+      diagnostics.push({
+        severity: "warning",
+        code: "target-in-transaction",
+        message: `The target handle is already inside a transaction. A full dump's own BEGIN TRANSACTION will fail; commit first, or restore with transaction: "wrap".`
+      });
+    }
+    const database = request.database;
+    if (database) {
+      diagnostics.push(
+        ...checkTargetCompatibility(database, capabilities, {
+          ...request.options,
+          ...modules === void 0 ? {} : { modules: new Set(modules.map(toAsciiLowerCase)) }
+        })
+      );
+      const hasVirtualTables = database.tables.some((table) => table.kind === "virtual");
+      if (hasVirtualTables && !connection.setDefensive) {
+        diagnostics.push({
+          severity: "warning",
+          code: "defensive-mode-not-controllable",
+          message: "This dump recreates virtual tables by writing sqlite_schema directly, which SQLITE_DBCONFIG_DEFENSIVE forbids, and this adapter cannot turn defensive mode off. The restore succeeds only if the connection is not in defensive mode."
+        });
+      }
+      const hasStat4 = database.tables.some((table) => table.name === "sqlite_stat4");
+      if (hasStat4 && compileOptions && !compileOptions.includes("ENABLE_STAT4")) {
+        diagnostics.push({
+          severity: "error",
+          code: "statistics-table-unsupported",
+          message: "The source database has a sqlite_stat4 table, and the target SQLite is not built with SQLITE_ENABLE_STAT4, so ANALYZE there does not create it and the dump's INSERT INTO sqlite_stat4 fails. The native .dump of such a database fails the same way. Dump with objectKinds.includeSystemTables: false, or drop sqlite_stat4 from the source copy first."
+        });
+      }
+      if (database.encoding.toUpperCase() !== encoding.toUpperCase()) {
+        diagnostics.push({
+          severity: "info",
+          code: "encoding-differs",
+          message: `The source database is ${database.encoding} and the target is ${encoding}. Text is converted between the two on restore, which is lossless for valid text.`
+        });
+      }
+      if (!request.options?.addDropStatements) {
+        const existing = new Map(
+          existingObjects.map((object) => [toAsciiLowerCase(object.name), object])
+        );
+        const created = [
+          ...database.tables.filter((table) => table.kind !== "system").map((table) => table.name),
+          ...database.views.map((view) => view.name),
+          ...database.indexes.filter((index) => index.sql !== null).map((index) => index.name),
+          ...database.triggers.map((trigger) => trigger.name)
+        ];
+        for (const name of created) {
+          const conflict = existing.get(toAsciiLowerCase(name));
+          if (conflict) {
+            diagnostics.push({
+              severity: "error",
+              code: "object-already-exists",
+              message: `The target already has a ${conflict.type} named "${conflict.name}", so the dump's CREATE for it will fail. Restore into an empty database, drop it first, or render the dump with addDropStatements.`,
+              objectReference: { kind: "table", schemaName: "main", name: conflict.name }
+            });
+          }
+        }
+      }
+    }
+    return {
+      version,
+      capabilities,
+      encoding,
+      foreignKeysEnabled,
+      ...inTransaction === void 0 ? {} : { inTransaction },
+      canDisableDefensiveMode: typeof connection.setDefensive === "function",
+      ...modules === void 0 ? {} : { modules },
+      ...compileOptions === void 0 ? {} : { compileOptions },
+      existingObjects,
+      diagnostics
+    };
+  } finally {
+    await acquired.release();
+  }
+}
+
+// src/restore/errors.ts
+var RestoreError = class extends SqliteDumperError {
+};
+var SqlParseError = class extends RestoreError {
+  line;
+  constructor(code, message, line, options) {
+    super(code, message, options);
+    this.name = "SqlParseError";
+    this.line = line;
+  }
+};
+var MalformedSqlDumpError = class extends SqlParseError {
+  openConstruct;
+  constructor(openConstruct, line) {
+    super(
+      "malformed-sql-dump",
+      `Unterminated ${openConstruct} starting at line ${line}: the input ends before it is closed`,
+      line
+    );
+    this.name = "MalformedSqlDumpError";
+    this.openConstruct = openConstruct;
+  }
+};
+var StatementTooLargeError = class extends SqlParseError {
+  maxStatementBytes;
+  constructor(maxStatementBytes, line) {
+    super(
+      "statement-too-large",
+      `Statement starting near line ${line} exceeds the configured limit of ${maxStatementBytes} bytes without being complete; increase options.maxStatementBytes if this statement is genuinely intended to be this large, or check for a CREATE TRIGGER missing its END`,
+      line
+    );
+    this.name = "StatementTooLargeError";
+    this.maxStatementBytes = maxStatementBytes;
+  }
+};
+var UnsupportedClientCommandError = class extends SqlParseError {
+  command;
+  constructor(command, line) {
+    super(
+      "unsupported-client-command",
+      `Unsupported sqlite3 shell command ".${command}" on line ${line}: dbgate-sqlite-dumper executes SQL statements and does not implement shell dot-commands that change the database. Run this script through the sqlite3 shell, or remove the command.`,
+      line
+    );
+    this.name = "UnsupportedClientCommandError";
+    this.command = command;
+  }
+};
+var InvalidTextEncodingError = class extends SqlParseError {
+  constructor(message, line) {
+    super("invalid-text-encoding", `${message} (near line ${line})`, line);
+    this.name = "InvalidTextEncodingError";
+  }
+};
+var RestoreExecutionError = class extends RestoreError {
+  statementIndex;
+  location;
+  sqlPreview;
+  sqliteError;
+  constructor(statementIndex, location, sqlPreview, message, sqliteError, options) {
+    super("restore-execution-failed", message, options);
+    this.name = "RestoreExecutionError";
+    this.statementIndex = statementIndex;
+    this.location = location;
+    this.sqlPreview = sqlPreview;
+    if (sqliteError) {
+      this.sqliteError = sqliteError;
+    }
+  }
+};
+
+// src/restore/statementInfo.ts
+function leadingTokens(sql, limit) {
+  const tokens = [];
+  let index = 0;
+  const length = sql.length;
+  while (index < length && tokens.length < limit) {
+    const character = sql[index];
+    const code = sql.charCodeAt(index);
+    if (/\s/.test(character) || character === "\uFEFF") {
+      index++;
+      continue;
+    }
+    if (character === "-" && sql[index + 1] === "-") {
+      const end = sql.indexOf("\n", index);
+      index = end === -1 ? length : end + 1;
+      continue;
+    }
+    if (character === "/" && sql[index + 1] === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      index = end === -1 ? length : end + 2;
+      continue;
+    }
+    if (character === '"' || character === "`" || character === "'" || character === "[") {
+      const close = character === "[" ? "]" : character;
+      let value = "";
+      index++;
+      while (index < length) {
+        if (sql[index] === close) {
+          if (close !== "]" && sql[index + 1] === close) {
+            value += close;
+            index += 2;
+            continue;
+          }
+          index++;
+          break;
+        }
+        value += sql[index];
+        index++;
+      }
+      tokens.push({ kind: character === "'" ? "string" : "quoted", value });
+      continue;
+    }
+    if (code >= 48 && code <= 57) {
+      let end = index + 1;
+      while (end < length && /[0-9A-Za-z_.+-]/.test(sql[end])) {
+        end++;
+      }
+      tokens.push({ kind: "number", value: sql.slice(index, end) });
+      index = end;
+      continue;
+    }
+    if (isIdentifierCharCode(code)) {
+      let end = index + 1;
+      while (end < length && isIdentifierCharCode(sql.charCodeAt(end))) {
+        end++;
+      }
+      tokens.push({ kind: "word", value: sql.slice(index, end) });
+      index = end;
+      continue;
+    }
+    tokens.push({ kind: "punct", value: character });
+    index++;
+  }
+  return tokens;
+}
+function nameToken(token) {
+  if (!token) {
+    return void 0;
+  }
+  return token.kind === "word" || token.kind === "quoted" || token.kind === "string" ? token.value : void 0;
+}
+function qualifiedName(tokens, position) {
+  const first = nameToken(tokens[position]);
+  if (first === void 0) {
+    return { next: position };
+  }
+  if (tokens[position + 1]?.kind === "punct" && tokens[position + 1]?.value === ".") {
+    const second = nameToken(tokens[position + 2]);
+    return second === void 0 ? { name: first, next: position + 1 } : { name: second, next: position + 3 };
+  }
+  return { name: first, next: position + 1 };
+}
+function isWord(token, word) {
+  return token?.kind === "word" && toAsciiUpperCase(token.value) === word;
+}
+function describeStatement(sql) {
+  const tokens = leadingTokens(sql, 12);
+  const first = tokens[0];
+  if (!first || first.kind !== "word") {
+    return { verb: "" };
+  }
+  const verb = toAsciiUpperCase(first.value);
+  switch (verb) {
+    case "BEGIN":
+      return { verb, transactionControl: "begin" };
+    case "COMMIT":
+    case "END":
+      return { verb, transactionControl: "commit" };
+    case "ROLLBACK": {
+      const toPosition = isWord(tokens[1], "TRANSACTION") ? 2 : 1;
+      return isWord(tokens[toPosition], "TO") ? { verb, transactionControl: "rollback-to-savepoint" } : { verb, transactionControl: "rollback" };
+    }
+    case "SAVEPOINT":
+      return { verb, transactionControl: "savepoint" };
+    case "RELEASE":
+      return { verb, transactionControl: "release" };
+    case "PRAGMA": {
+      const { name, next } = qualifiedName(tokens, 1);
+      if (name === void 0) {
+        return { verb };
+      }
+      const pragmaName = toAsciiLowerCase(name);
+      const operator = tokens[next];
+      if (operator?.kind === "punct" && (operator.value === "=" || operator.value === "(")) {
+        const valueToken = tokens[next + 1];
+        let value = valueToken?.value;
+        if (valueToken?.kind === "punct" && (valueToken.value === "-" || valueToken.value === "+")) {
+          value = `${valueToken.value}${tokens[next + 2]?.value ?? ""}`;
+        }
+        return value === void 0 ? { verb, pragmaName } : { verb, pragmaName, pragmaValue: value };
+      }
+      return { verb, pragmaName };
+    }
+    case "INSERT":
+    case "REPLACE": {
+      let position = 1;
+      if (verb === "INSERT" && isWord(tokens[1], "OR")) {
+        position = 3;
+      }
+      if (isWord(tokens[position], "INTO")) {
+        position++;
+      }
+      const { name } = qualifiedName(tokens, position);
+      return name === void 0 ? { verb } : { verb, objectName: name };
+    }
+    case "DELETE": {
+      const position = isWord(tokens[1], "FROM") ? 2 : 1;
+      const { name } = qualifiedName(tokens, position);
+      return name === void 0 ? { verb } : { verb, objectName: name };
+    }
+    case "UPDATE":
+    case "ANALYZE":
+    case "DROP": {
+      let position = 1;
+      let objectKind;
+      if (verb === "DROP" && tokens[1]?.kind === "word") {
+        objectKind = toAsciiUpperCase(tokens[1].value);
+        position = 2;
+        if (isWord(tokens[2], "IF") && isWord(tokens[3], "EXISTS")) {
+          position = 4;
+        }
+      }
+      const { name } = qualifiedName(tokens, position);
+      return {
+        verb,
+        ...objectKind === void 0 ? {} : { objectKind },
+        ...name === void 0 ? {} : { objectName: name }
+      };
+    }
+    case "CREATE": {
+      let position = 1;
+      while (isWord(tokens[position], "TEMP") || isWord(tokens[position], "TEMPORARY") || isWord(tokens[position], "UNIQUE")) {
+        position++;
+      }
+      let objectKind = tokens[position]?.kind === "word" ? toAsciiUpperCase(tokens[position].value) : "";
+      position++;
+      if (objectKind === "VIRTUAL" && isWord(tokens[position], "TABLE")) {
+        objectKind = "VIRTUAL TABLE";
+        position++;
+      }
+      if (isWord(tokens[position], "IF") && isWord(tokens[position + 1], "NOT")) {
+        position += 3;
+      }
+      const { name } = qualifiedName(tokens, position);
+      return {
+        verb,
+        ...objectKind === "" ? {} : { objectKind },
+        ...name === void 0 ? {} : { objectName: name }
+      };
+    }
+    default:
+      return { verb };
+  }
+}
+
+// src/restore/textEncoding.ts
+var import_node_buffer2 = require("buffer");
+function decodeStatementBytes(statement, startLine) {
+  const bytes = Buffer.from(statement, "latin1");
+  if ((0, import_node_buffer2.isUtf8)(bytes)) {
+    return { sql: bytes.toString("utf8"), literalsRewritten: 0 };
+  }
+  let output = "";
+  let literalsRewritten = 0;
+  let line = startLine;
+  let index = 0;
+  const length = statement.length;
+  const appendPlain = (segment) => {
+    const segmentBytes = Buffer.from(segment, "latin1");
+    if (!(0, import_node_buffer2.isUtf8)(segmentBytes)) {
+      throw new InvalidTextEncodingError(
+        "The statement contains bytes that are not valid UTF-8 outside any string literal, so it cannot be executed as text without corrupting them",
+        line
+      );
+    }
+    output += segmentBytes.toString("utf8");
+  };
+  let plainStart = 0;
+  while (index < length) {
+    const character = statement[index];
+    if (character === "\n") {
+      line++;
+      index++;
+      continue;
+    }
+    if (character === "'") {
+      appendPlain(statement.slice(plainStart, index));
+      let end = index + 1;
+      for (; ; ) {
+        const close = statement.indexOf("'", end);
+        if (close === -1) {
+          end = length;
+          break;
+        }
+        if (statement[close + 1] === "'") {
+          end = close + 2;
+          continue;
+        }
+        end = close + 1;
+        break;
+      }
+      const literal = statement.slice(index, end);
+      const literalBytes = Buffer.from(literal, "latin1");
+      if ((0, import_node_buffer2.isUtf8)(literalBytes)) {
+        output += literalBytes.toString("utf8");
+      } else {
+        const value = literal.slice(1, literal.endsWith("'") ? -1 : void 0).replace(/''/g, "'");
+        output += `(CAST(X'${Buffer.from(value, "latin1").toString("hex")}' AS TEXT))`;
+        literalsRewritten++;
+      }
+      for (let scan = index; scan < end; scan++) {
+        if (statement[scan] === "\n") line++;
+      }
+      index = end;
+      plainStart = end;
+      continue;
+    }
+    if (character === '"' || character === "`" || character === "[") {
+      const close = character === "[" ? "]" : character;
+      let end = statement.indexOf(close, index + 1);
+      end = end === -1 ? length : end + 1;
+      index = end;
+      continue;
+    }
+    if (character === "-" && statement[index + 1] === "-") {
+      appendPlain(statement.slice(plainStart, index));
+      const end = statement.indexOf("\n", index);
+      const commentEnd = end === -1 ? length : end;
+      const comment = statement.slice(index, commentEnd);
+      output += (0, import_node_buffer2.isUtf8)(Buffer.from(comment, "latin1")) ? Buffer.from(comment, "latin1").toString("utf8") : "--";
+      index = commentEnd;
+      plainStart = commentEnd;
+      continue;
+    }
+    if (character === "/" && statement[index + 1] === "*") {
+      appendPlain(statement.slice(plainStart, index));
+      const end = statement.indexOf("*/", index + 2);
+      const commentEnd = end === -1 ? length : end + 2;
+      const comment = statement.slice(index, commentEnd);
+      const commentBytes = Buffer.from(comment, "latin1");
+      output += (0, import_node_buffer2.isUtf8)(commentBytes) ? commentBytes.toString("utf8") : " ";
+      for (let scan = index; scan < commentEnd; scan++) {
+        if (statement[scan] === "\n") line++;
+      }
+      index = commentEnd;
+      plainStart = commentEnd;
+      continue;
+    }
+    index++;
+  }
+  appendPlain(statement.slice(plainStart));
+  return { sql: output, literalsRewritten };
+}
+
+// src/restore/statementParser.ts
+var DEFAULT_MAX_STATEMENT_BYTES2 = 256 * 1024 * 1024;
+var MAX_TERMINATOR_LINE_BYTES = 64 * 1024;
+var MAX_DOT_COMMAND_BYTES = 64 * 1024;
+var PRESENTATIONAL_DOT_COMMANDS = /* @__PURE__ */ new Set([
+  "bail",
+  "binary",
+  "changes",
+  "databases",
+  "dbinfo",
+  "echo",
+  "eqp",
+  "explain",
+  "fullschema",
+  "headers",
+  "header",
+  "help",
+  "indexes",
+  "indices",
+  "log",
+  "mode",
+  "nullvalue",
+  "once",
+  "output",
+  "print",
+  "progress",
+  "prompt",
+  "scanstats",
+  "schema",
+  "separator",
+  "show",
+  "stats",
+  "tables",
+  "timeout",
+  "timer",
+  "trace",
+  "width"
+]);
+var EXIT_DOT_COMMANDS = /* @__PURE__ */ new Set(["exit", "quit"]);
+var OPEN_CONSTRUCT_NAME = {
+  singleQuote: "string literal ('...')",
+  doubleQuote: 'double-quoted identifier ("...")',
+  backtick: "backtick-quoted identifier (`...`)",
+  bracket: "bracket-quoted identifier ([...])"
+};
+var CLOSING_CHARACTER = {
+  singleQuote: "'",
+  doubleQuote: '"',
+  backtick: "`",
+  bracket: "]"
+};
+function isCompleteWhitespace2(character) {
+  return character === " " || character === "\n" || character === "	" || character === "\r" || character === "\f";
+}
+function isCSpace(character) {
+  return isCompleteWhitespace2(character) || character === "\v";
+}
+function isPlainWhiteLine(text) {
+  let index = 0;
+  while (index < text.length) {
+    const character = text[index];
+    if (isCSpace(character)) {
+      index++;
+      continue;
+    }
+    if (character === "-" && text[index + 1] === "-") {
+      return true;
+    }
+    if (character === "/" && text[index + 1] === "*") {
+      const end = text.indexOf("*/", index + 2);
+      if (end === -1) {
+        return false;
+      }
+      index = end + 2;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isTerminatorLine(line) {
+  let index = 0;
+  while (index < line.length && isCSpace(line[index])) {
+    index++;
+  }
+  if (line[index] === "/") {
+    return isPlainWhiteLine(line.slice(index + 1));
+  }
+  if ((line[index] ?? "").toLowerCase() === "g" && (line[index + 1] ?? "").toLowerCase() === "o") {
+    return isPlainWhiteLine(line.slice(index + 2));
+  }
+  return false;
+}
+function couldBeTerminatorLine(partial) {
+  let index = 0;
+  while (index < partial.length && isCSpace(partial[index])) {
+    index++;
+  }
+  if (index >= partial.length) {
+    return true;
+  }
+  const first = partial[index].toLowerCase();
+  if (first === "/") {
+    return true;
+  }
+  return first === "g" && (index + 1 >= partial.length || partial[index + 1].toLowerCase() === "o");
+}
+var SqlStatementParser = class {
+  maxStatementBytes;
+  dotCommandPolicy;
+  lex = "normal";
+  completeState = 0;
+  /** Length and (lower-cased, capped) prefix of the identifier being scanned. */
+  wordLength = 0;
+  wordPrefix = "";
+  /** In a block comment: whether the previous byte was `*`. */
+  blockStar = false;
+  openLine = 1;
+  carry = "";
+  parts = [];
+  partsBytes = 0;
+  /** True once the pending statement has content other than whitespace and comments. */
+  hasContent = false;
+  statementStartLine = 1;
+  line = 1;
+  atLineStart = true;
+  firstChunk = true;
+  dotText = "";
+  dotLine = 1;
+  nextStatementIndex = 0;
+  finished = false;
+  bytesConsumedTotal = 0;
+  lastObject;
+  skipped = [];
+  constructor(options) {
+    this.maxStatementBytes = options?.maxStatementBytes ?? DEFAULT_MAX_STATEMENT_BYTES2;
+    this.dotCommandPolicy = options?.dotCommands ?? "skip-presentational";
+  }
+  /** Bytes of source consumed so far. */
+  get bytesConsumed() {
+    return this.bytesConsumedTotal;
+  }
+  /** Dot-commands skipped so far under the `'skip-presentational'` policy. */
+  get skippedDotCommands() {
+    return this.skipped;
+  }
+  /** `true` once a `.quit`/`.exit` command ended the input. */
+  get stopped() {
+    return this.lex === "stopped";
+  }
+  /**
+   * Feeds one chunk of the source, as a **byte string** — one code unit per
+   * byte, as produced by `buffer.toString('latin1')`. Callers holding text
+   * should use {@link parseSqlStatements} or {@link streamSqlStatements},
+   * which convert for them.
+   */
+  push(chunk) {
+    if (this.finished) {
+      throw new Error("SqlStatementParser.push() called after finish()");
+    }
+    this.bytesConsumedTotal += chunk.length;
+    if (chunk.length === 0) {
+      return [];
+    }
+    return this.scan(this.carry + chunk, false);
+  }
+  finish() {
+    if (this.finished) {
+      throw new Error("SqlStatementParser.finish() called more than once");
+    }
+    this.finished = true;
+    const out = this.scan(this.carry, true);
+    this.carry = "";
+    const open = OPEN_CONSTRUCT_NAME[this.lex];
+    if (open !== void 0) {
+      throw new MalformedSqlDumpError(open, this.openLine);
+    }
+    if (this.lex === "dotCommand") {
+      this.handleDotCommand();
+    }
+    if (this.lex !== "stopped") {
+      this.endWord();
+      const statement = this.emit();
+      if (statement) {
+        out.push(statement);
+      }
+    }
+    return out;
+  }
+  scan(text, final) {
+    const out = [];
+    const length = text.length;
+    let index = 0;
+    let keepFrom = this.hasContent && this.lex !== "stopped" ? 0 : -1;
+    const flush = (end) => {
+      if (keepFrom >= 0 && end > keepFrom) {
+        const part = text.slice(keepFrom, end);
+        this.parts.push(part);
+        this.partsBytes += part.length;
+        if (this.partsBytes > this.maxStatementBytes) {
+          throw new StatementTooLargeError(this.maxStatementBytes, this.statementStartLine);
+        }
+      }
+      keepFrom = -1;
+    };
+    const markContent = (at) => {
+      if (!this.hasContent) {
+        this.hasContent = true;
+        this.statementStartLine = this.line;
+        keepFrom = at;
+      } else if (keepFrom < 0) {
+        keepFrom = at;
+      }
+    };
+    const resume = (at) => {
+      if (this.hasContent && keepFrom < 0) {
+        keepFrom = at;
+      }
+    };
+    const carryFrom = (at) => {
+      flush(at);
+      this.carry = text.slice(at);
+    };
+    if (this.firstChunk && length > 0) {
+      if (text.startsWith("\xEF\xBB\xBF")) {
+        index = 3;
+        this.firstChunk = false;
+      } else if (!final && "\xEF\xBB\xBF".startsWith(text)) {
+        this.carry = text;
+        return out;
+      } else {
+        this.firstChunk = false;
+      }
+    }
+    while (index < length) {
+      const character = text[index];
+      if (character === "\r" && this.lex !== "stopped") {
+        if (index + 1 >= length && !final) {
+          carryFrom(index);
+          return out;
+        }
+        if (text[index + 1] === "\n") {
+          flush(index);
+          index++;
+          resume(index);
+          continue;
+        }
+      }
+      switch (this.lex) {
+        case "stopped":
+          index = length;
+          continue;
+        case "hashComment":
+        case "dotCommand": {
+          const newline = text.indexOf("\n", index);
+          const end = newline === -1 ? length : newline;
+          if (this.lex === "dotCommand" && this.dotText.length < MAX_DOT_COMMAND_BYTES) {
+            this.dotText += text.slice(index, end);
+          }
+          if (newline === -1) {
+            index = length;
+            continue;
+          }
+          if (this.lex === "dotCommand") {
+            this.handleDotCommand();
+            if (this.stopped) {
+              index = length;
+              continue;
+            }
+          }
+          this.lex = "normal";
+          index = newline;
+          continue;
+        }
+        case "singleQuote":
+        case "doubleQuote":
+        case "backtick":
+        case "bracket": {
+          const close = CLOSING_CHARACTER[this.lex];
+          if (character === close) {
+            this.lex = "normal";
+            this.atLineStart = false;
+            index++;
+            continue;
+          }
+          if (character === "\r") {
+            index++;
+            continue;
+          }
+          let end = text.indexOf(close, index);
+          if (end === -1) end = length;
+          const crAt = text.indexOf("\r", index);
+          if (crAt !== -1 && crAt < end) end = crAt;
+          this.countNewlines(text, index, end);
+          index = end;
+          continue;
+        }
+        case "blockComment": {
+          if (this.blockStar && character === "/") {
+            this.blockStar = false;
+            this.lex = "normal";
+            this.completeState = completeTransition(this.completeState, CompleteToken.Whitespace);
+            this.atLineStart = false;
+            index++;
+            continue;
+          }
+          const starAt = text.indexOf("*", index);
+          const crAt = text.indexOf("\r", index);
+          let end = starAt === -1 ? length : starAt;
+          if (crAt !== -1 && crAt < end) {
+            end = crAt;
+          }
+          if (end > index) {
+            this.countNewlines(text, index, end);
+            this.blockStar = false;
+            index = end;
+            continue;
+          }
+          if (character === "*") {
+            this.blockStar = true;
+            this.atLineStart = false;
+            if (index + 1 >= length && !final) {
+              index++;
+              continue;
+            }
+            index++;
+            continue;
+          }
+          this.blockStar = false;
+          index++;
+          continue;
+        }
+        case "lineComment": {
+          if (character === "\n") {
+            this.lex = "normal";
+            continue;
+          }
+          if (character === "\r") {
+            index++;
+            continue;
+          }
+          let end = text.indexOf("\n", index);
+          if (end === -1) end = length;
+          const crAt = text.indexOf("\r", index);
+          if (crAt !== -1 && crAt < end) end = crAt;
+          index = end;
+          continue;
+        }
+        case "normal":
+          break;
+      }
+      const code = text.charCodeAt(index);
+      if (this.wordLength > 0) {
+        if (isIdentifierCharCode(code)) {
+          const start = index;
+          while (index < length && isIdentifierCharCode(text.charCodeAt(index))) {
+            index++;
+          }
+          this.extendWord(text.slice(start, index));
+          continue;
+        }
+        this.endWord();
+      }
+      if (this.atLineStart) {
+        this.atLineStart = false;
+        if (!this.hasContent && (character === "." || character === "#")) {
+          this.lex = character === "." ? "dotCommand" : "hashComment";
+          this.dotText = "";
+          this.dotLine = this.line;
+          index++;
+          continue;
+        }
+        if (this.completeState !== 5 && this.completeState !== 6 && this.mayStartTerminatorLine(text, index, final)) {
+          const newline = text.indexOf("\n", index);
+          const lineEnd = newline === -1 ? length : newline;
+          const lineText = text.slice(index, lineEnd);
+          if (newline === -1 && !final) {
+            if (lineText.length < MAX_TERMINATOR_LINE_BYTES && couldBeTerminatorLine(lineText)) {
+              this.atLineStart = true;
+              carryFrom(index);
+              return out;
+            }
+          } else if (isTerminatorLine(lineText)) {
+            flush(index);
+            const statement = this.completeWithSemicolon();
+            if (statement) {
+              out.push(statement);
+            }
+            index = lineEnd;
+            continue;
+          }
+        }
+      }
+      if (character === ";") {
+        const next = completeTransition(this.completeState, CompleteToken.Semi);
+        if (next === 1) {
+          flush(index);
+          this.completeState = next;
+          const statement = this.emit();
+          if (statement) {
+            out.push(statement);
+          }
+          index++;
+          continue;
+        }
+        this.completeState = next;
+        markContent(index);
+        index++;
+        continue;
+      }
+      if (isCompleteWhitespace2(character)) {
+        this.completeState = completeTransition(this.completeState, CompleteToken.Whitespace);
+        if (character === "\n") {
+          this.line++;
+          this.atLineStart = true;
+        }
+        index++;
+        continue;
+      }
+      if (character === "-" || character === "/") {
+        if (index + 1 >= length && !final) {
+          carryFrom(index);
+          return out;
+        }
+        const next = text[index + 1];
+        if (character === "-" && next === "-" || character === "/" && next === "*") {
+          this.lex = character === "-" ? "lineComment" : "blockComment";
+          this.blockStar = false;
+          if (character === "-") {
+            this.completeState = completeTransition(this.completeState, CompleteToken.Whitespace);
+          }
+          index += 2;
+          continue;
+        }
+        this.completeState = completeTransition(this.completeState, CompleteToken.Other);
+        markContent(index);
+        index++;
+        continue;
+      }
+      if (character === "'" || character === '"' || character === "`" || character === "[") {
+        this.lex = character === "'" ? "singleQuote" : character === '"' ? "doubleQuote" : character === "`" ? "backtick" : "bracket";
+        this.openLine = this.line;
+        this.completeState = completeTransition(this.completeState, CompleteToken.Other);
+        markContent(index);
+        index++;
+        continue;
+      }
+      if (code === 239) {
+        if (index + 2 >= length && !final) {
+          carryFrom(index);
+          return out;
+        }
+        if (text.charCodeAt(index + 1) === 187 && text.charCodeAt(index + 2) === 191) {
+          flush(index);
+          index += 3;
+          resume(index);
+          continue;
+        }
+      }
+      if (isIdentifierCharCode(code)) {
+        markContent(index);
+        const start = index;
+        while (index < length && isIdentifierCharCode(text.charCodeAt(index))) {
+          index++;
+        }
+        this.extendWord(text.slice(start, index));
+        continue;
+      }
+      this.completeState = completeTransition(this.completeState, CompleteToken.Other);
+      markContent(index);
+      index++;
+    }
+    flush(length);
+    this.carry = "";
+    return out;
+  }
+  /**
+   * Cheap pre-check before the terminator-line lookahead: only a line whose
+   * first non-blank character is `/` or `g` can be one. Keeps the lookahead —
+   * which has to look at the whole line — off the ordinary `INSERT` lines
+   * that make up almost all of a dump.
+   */
+  mayStartTerminatorLine(text, index, final) {
+    let probe = index;
+    while (probe < text.length && text[probe] !== "\n" && isCSpace(text[probe])) {
+      probe++;
+    }
+    if (probe >= text.length) {
+      return !final;
+    }
+    const first = text[probe];
+    return first === "/" || first === "g" || first === "G";
+  }
+  countNewlines(text, start, end) {
+    let position = text.indexOf("\n", start);
+    while (position !== -1 && position < end) {
+      this.line++;
+      position = text.indexOf("\n", position + 1);
+    }
+    if (end > start) {
+      this.atLineStart = text[end - 1] === "\n";
+    }
+  }
+  extendWord(segment) {
+    if (this.wordPrefix.length < 10) {
+      this.wordPrefix += segment.slice(0, 10 - this.wordPrefix.length);
+    }
+    this.wordLength += segment.length;
+  }
+  endWord() {
+    if (this.wordLength === 0) {
+      return;
+    }
+    const token = this.wordLength > 9 ? CompleteToken.Other : classifyWord(this.wordPrefix);
+    this.completeState = completeTransition(this.completeState, token);
+    this.wordLength = 0;
+    this.wordPrefix = "";
+  }
+  /** A terminator line: behave as if the line were `;`. */
+  completeWithSemicolon() {
+    this.completeState = completeTransition(this.completeState, CompleteToken.Semi);
+    return this.emit();
+  }
+  emit() {
+    const hadContent = this.hasContent;
+    const byteText = this.parts.join("");
+    this.parts = [];
+    this.partsBytes = 0;
+    this.hasContent = false;
+    if (!hadContent) {
+      return null;
+    }
+    const trimmed = byteText.replace(/[ \t\n\r\f\v]+$/, "");
+    if (trimmed === "") {
+      return null;
+    }
+    const { sql, literalsRewritten } = decodeStatementBytes(trimmed, this.statementStartLine);
+    const info = describeStatement(sql);
+    if (info.objectName !== void 0) {
+      this.lastObject = info.objectName;
+    }
+    return {
+      statementIndex: this.nextStatementIndex++,
+      sql,
+      location: { startLine: this.statementStartLine, endLine: this.line },
+      info,
+      ...this.lastObject === void 0 ? {} : { currentObject: this.lastObject },
+      bytesConsumed: this.bytesConsumedTotal,
+      textLiteralsRewritten: literalsRewritten
+    };
+  }
+  handleDotCommand() {
+    const text = this.dotText;
+    this.dotText = "";
+    this.lex = "normal";
+    const command = (/^\S*/.exec(text)?.[0] ?? "").toLowerCase();
+    if (EXIT_DOT_COMMANDS.has(command)) {
+      this.lex = "stopped";
+      return;
+    }
+    if (this.dotCommandPolicy === "skip-presentational" && PRESENTATIONAL_DOT_COMMANDS.has(command)) {
+      this.skipped.push({ command, line: this.dotLine });
+      return;
+    }
+    throw new UnsupportedClientCommandError(command, this.dotLine);
+  }
+};
+function parseSqlStatements(sql, options) {
+  const parser = new SqlStatementParser(options);
+  const byteString = (typeof sql === "string" ? Buffer.from(sql, "utf8") : sql).toString("latin1");
+  return [...parser.push(byteString), ...parser.finish()];
+}
+async function* toByteStringChunks(source) {
+  if (typeof source === "string") {
+    yield Buffer.from(source, "utf8").toString("latin1");
+    return;
+  }
+  if (source instanceof Uint8Array) {
+    yield (Buffer.isBuffer(source) ? source : Buffer.from(source)).toString("latin1");
+    return;
+  }
+  for await (const chunk of source) {
+    if (typeof chunk === "string") {
+      yield Buffer.from(chunk, "utf8").toString("latin1");
+    } else {
+      yield (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).toString("latin1");
+    }
+  }
+}
+async function* streamSqlStatements(source, options, signal) {
+  const parser = new SqlStatementParser(options);
+  yield* streamWithParser(parser, source, signal);
+}
+async function* streamWithParser(parser, source, signal) {
+  for await (const chunk of toByteStringChunks(source)) {
+    throwIfAborted2(signal);
+    for (const statement of parser.push(chunk)) {
+      yield statement;
+    }
+    if (parser.stopped) {
+      break;
+    }
+  }
+  throwIfAborted2(signal);
+  for (const statement of parser.finish()) {
+    yield statement;
+  }
+}
+
+// src/restore/sessionState.ts
+var TRUTHY_PRAGMA_VALUES = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
+function isTruthyPragmaValue(value) {
+  return value !== void 0 && TRUTHY_PRAGMA_VALUES.has(value.trim().toLowerCase());
+}
+var RestoreSessionState = class {
+  initialForeignKeys;
+  foreignKeysChanged = false;
+  writableSchemaOn = false;
+  schemaRowsWritten = false;
+  /** Tracked when the adapter cannot report `isInTransaction()`. */
+  trackedTransaction = false;
+  callerTransaction = false;
+  /** Records the state to restore to. Call once, before the first statement. */
+  async begin(connection, signal) {
+    this.callerTransaction = connection.isInTransaction?.() ?? false;
+    try {
+      const result = await connection.query({ sql: "PRAGMA foreign_keys" }, signal);
+      const first = result.rows[0];
+      if (first !== void 0) {
+        this.initialForeignKeys = toNumber(Object.values(first)[0]) !== 0;
+      }
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+    }
+  }
+  /** Whether the handle was already inside a transaction the caller opened. */
+  get joinedCallerTransaction() {
+    return this.callerTransaction;
+  }
+  /** Whether any statement wrote virtual-table rows into the schema table. */
+  get wroteSchemaRows() {
+    return this.schemaRowsWritten;
+  }
+  /** Call after every statement that executed successfully. */
+  observe(info) {
+    if (info.transactionControl === "begin") {
+      this.trackedTransaction = true;
+    } else if (info.transactionControl === "commit" || info.transactionControl === "rollback") {
+      this.trackedTransaction = false;
+    } else if (info.transactionControl === "savepoint" && !this.trackedTransaction) {
+      this.trackedTransaction = true;
+    }
+    if (info.verb === "PRAGMA" && info.pragmaValue !== void 0) {
+      if (info.pragmaName === "foreign_keys") {
+        this.foreignKeysChanged = true;
+      } else if (info.pragmaName === "writable_schema") {
+        this.writableSchemaOn = isTruthyPragmaValue(info.pragmaValue);
+      }
+    }
+    if (info.verb === "INSERT" && isSchemaTableName(info.objectName)) {
+      this.schemaRowsWritten = true;
+    }
+  }
+  /** Whether a transaction the script (not the caller) opened is still open. */
+  scriptTransactionOpen(connection) {
+    if (this.callerTransaction) {
+      return false;
+    }
+    return connection.isInTransaction?.() ?? this.trackedTransaction;
+  }
+  /**
+   * Puts back what the script changed. Runs without the caller's signal on
+   * purpose: on the cancellation path that signal is already aborted, and
+   * the cleanup must still happen. Returns a description of each change it
+   * undid, for the `session-state-restored` warning.
+   */
+  async restore(connection, options) {
+    const restored = [];
+    let rolledBack = false;
+    if (options.rollbackOpenTransaction && this.scriptTransactionOpen(connection)) {
+      await executeStatement(connection, "ROLLBACK").catch(() => {
+      });
+      this.trackedTransaction = false;
+      rolledBack = true;
+    }
+    if (this.writableSchemaOn) {
+      await executeStatement(connection, "PRAGMA writable_schema=OFF").catch(() => {
+      });
+      this.writableSchemaOn = false;
+      restored.push("writable_schema");
+    }
+    if (this.foreignKeysChanged && this.initialForeignKeys !== void 0) {
+      await executeStatement(
+        connection,
+        `PRAGMA foreign_keys=${this.initialForeignKeys ? "ON" : "OFF"}`
+      ).catch(() => {
+      });
+      this.foreignKeysChanged = false;
+    }
+    return { rolledBack, restored };
+  }
+};
+function isSchemaTableName(name) {
+  if (name === void 0) {
+    return false;
+  }
+  const lower = name.toLowerCase();
+  return lower === "sqlite_schema" || lower === "sqlite_master" || lower === "sqlite_temp_schema" || lower === "sqlite_temp_master";
+}
+
+// src/restore/restoreSqlDump.ts
+var WRAP_SAVEPOINT = "dbgate_sqlite_restore";
+var MAX_REPORTED_FOREIGN_KEY_VIOLATIONS = 20;
+async function restoreSqlDump(request) {
+  const options = request.options ?? {};
+  const stopOnError = options.stopOnError ?? true;
+  const restoreSessionStateOnExit = options.restoreSessionState ?? true;
+  const schemaWrites = options.schemaWrites ?? "allow";
+  const wrap = options.transaction === "wrap";
+  const signal = request.signal;
+  request.progress?.({ phase: "connecting" });
+  const acquired = await acquireSqliteConnection(request.connection, signal);
+  const connection = acquired.connection;
+  let statementsExecuted = 0;
+  let statementsFailed = 0;
+  let rowsRestored = 0;
+  let bytesConsumed = 0;
+  const errors = [];
+  const warnings = [];
+  const sessionState = new RestoreSessionState();
+  const parser = new SqlStatementParser(options);
+  let defensiveDisabled = false;
+  let wrapOpen = false;
+  let skippedTransactionControl = 0;
+  let textLiteralsRewritten = 0;
+  const result = (cancelled) => ({
+    statementsExecuted,
+    statementsFailed,
+    rowsRestored,
+    bytesConsumed,
+    errors,
+    warnings,
+    cancelled
+  });
+  const report = (phase, statement, executionState, error) => {
+    request.progress?.({
+      phase,
+      statementsProcessed: statementsExecuted + statementsFailed,
+      rowsRestored,
+      bytesConsumed,
+      ...statement === void 0 ? {} : {
+        statementIndex: statement.statementIndex,
+        ...statement.currentObject === void 0 ? {} : { currentObject: statement.currentObject }
+      },
+      ...executionState === void 0 ? {} : { executionState },
+      ...error === void 0 ? {} : {
+        error: {
+          statementIndex: error.statementIndex,
+          location: error.location,
+          sqlPreview: error.sqlPreview,
+          message: error.message
+        }
+      }
+    });
+  };
+  const closeWrap = async (commit) => {
+    if (!wrapOpen) {
+      return;
+    }
+    wrapOpen = false;
+    if (!commit) {
+      await executeStatement(connection, `ROLLBACK TO ${WRAP_SAVEPOINT}`).catch(() => {
+      });
+      warnings.push({
+        code: "transaction-rolled-back",
+        message: 'The restore did not complete, so its transaction (transaction: "wrap") was rolled back and the database is unchanged.'
+      });
+    }
+    await executeStatement(connection, `RELEASE ${WRAP_SAVEPOINT}`).catch(() => {
+    });
+  };
+  const finalize = async (completed) => {
+    await closeWrap(completed);
+    if (restoreSessionStateOnExit) {
+      const { rolledBack, restored } = await sessionState.restore(connection, {
+        rollbackOpenTransaction: true
+      });
+      if (rolledBack) {
+        warnings.push({
+          code: "transaction-rolled-back",
+          message: completed ? "The script opened a transaction and never committed it (a truncated dump ends this way), so it was rolled back \u2014 as the sqlite3 shell's exit would roll it back." : "The restore stopped inside the transaction the script opened, so that transaction was rolled back: nothing it had written so far was kept."
+        });
+      }
+      if (restored.length > 0) {
+        warnings.push({
+          code: "session-state-restored",
+          message: `The script left ${restored.join(", ")} changed when the restore ended, so it was reset before the connection was released.`
+        });
+      }
+    }
+    if (sessionState.wroteSchemaRows) {
+      await executeStatement(connection, "PRAGMA writable_schema=RESET").catch(() => {
+      });
+    }
+    if (defensiveDisabled && connection.setDefensive) {
+      await connection.setDefensive(true).catch(() => {
+      });
+      defensiveDisabled = false;
+    }
+    await acquired.release();
+  };
+  try {
+    await sessionState.begin(connection, signal);
+    if (options.disableForeignKeys) {
+      await executeStatement(connection, "PRAGMA foreign_keys=OFF", signal);
+      sessionState.observe({ verb: "PRAGMA", pragmaName: "foreign_keys", pragmaValue: "OFF" });
+    }
+    if (sessionState.joinedCallerTransaction && !wrap) {
+      warnings.push({
+        code: "caller-transaction-open",
+        message: `The connection was already inside a transaction when the restore started. A full dump's own BEGIN TRANSACTION will fail in that state; commit first, or restore with transaction: "wrap", which nests.`
+      });
+    }
+    for await (const statement of streamWithParser(parser, request.source, signal)) {
+      throwIfAborted2(signal);
+      bytesConsumed = statement.bytesConsumed;
+      textLiteralsRewritten += statement.textLiteralsRewritten;
+      report("parsing", statement);
+      const info = statement.info;
+      if (wrap) {
+        if (info.transactionControl === "begin" || info.transactionControl === "commit" || info.transactionControl === "rollback") {
+          skippedTransactionControl++;
+          continue;
+        }
+        if (!wrapOpen && info.verb !== "PRAGMA") {
+          await executeStatement(connection, `SAVEPOINT ${WRAP_SAVEPOINT}`, signal);
+          wrapOpen = true;
+        }
+      }
+      const schemaWriteRefused = schemaWrites === "refuse" && (info.verb === "INSERT" && isSchemaTableName(info.objectName) || info.pragmaName === "writable_schema" && isTruthyPragmaValue(info.pragmaValue));
+      if (!schemaWriteRefused && schemaWrites === "allow" && !defensiveDisabled && connection.setDefensive && info.pragmaName === "writable_schema" && isTruthyPragmaValue(info.pragmaValue)) {
+        await connection.setDefensive(false);
+        defensiveDisabled = true;
+        warnings.push({
+          code: "defensive-mode-disabled",
+          message: "The dump recreates virtual tables by writing sqlite_schema directly (as every native .dump of such a database does), so SQLITE_DBCONFIG_DEFENSIVE was disabled for the rest of the restore and re-enabled afterwards.",
+          statementIndex: statement.statementIndex
+        });
+      }
+      report("executing", statement, "started");
+      try {
+        if (schemaWriteRefused) {
+          throw new Error(
+            'Statement writes the schema table directly, which schemaWrites: "refuse" does not allow'
+          );
+        }
+        const executed = await executeStatement(connection, statement.sql, signal);
+        rowsRestored += executed.changes;
+        statementsExecuted++;
+        sessionState.observe(info);
+        report("executing", statement, "finished");
+      } catch (error) {
+        if (isAbortError(error)) {
+          throw error;
+        }
+        statementsFailed++;
+        const statementError = toStatementError(connection, statement, error);
+        errors.push(statementError);
+        report("executing", statement, "failed", statementError);
+        if (stopOnError) {
+          collectParserWarnings(parser, warnings, textLiteralsRewritten, skippedTransactionControl);
+          await finalize(false);
+          return result(false);
+        }
+      }
+    }
+    report("finalizing");
+    if (options.verifyForeignKeys) {
+      await closeWrap(true);
+      warnings.push(...await checkForeignKeys(connection, signal));
+    }
+    collectParserWarnings(parser, warnings, textLiteralsRewritten, skippedTransactionControl);
+    await finalize(true);
+    return result(false);
+  } catch (error) {
+    collectParserWarnings(parser, warnings, textLiteralsRewritten, skippedTransactionControl);
+    await finalize(false);
+    if (isAbortError(error)) {
+      return result(true);
+    }
+    throw error;
+  }
+}
+function collectParserWarnings(parser, warnings, textLiteralsRewritten, skippedTransactionControl) {
+  for (const skipped of parser.skippedDotCommands) {
+    warnings.push({
+      code: "dot-command-skipped",
+      message: `The sqlite3 shell command ".${skipped.command}" on line ${skipped.line} only affects the shell's own output, so it was skipped.`
+    });
+  }
+  if (textLiteralsRewritten > 0) {
+    warnings.push({
+      code: "text-literal-rewritten",
+      message: `${textLiteralsRewritten} string literal(s) held bytes that are not valid UTF-8 and were executed as CAST(X'...' AS TEXT), which stores the identical bytes.`
+    });
+  }
+  if (skippedTransactionControl > 0) {
+    warnings.push({
+      code: "script-transaction-control-skipped",
+      message: `${skippedTransactionControl} BEGIN/COMMIT/ROLLBACK statement(s) in the script were skipped, because transaction: "wrap" runs the whole restore in its own transaction.`
+    });
+  }
+}
+async function checkForeignKeys(connection, signal) {
+  const found = [];
+  let total = 0;
+  const byTable = /* @__PURE__ */ new Map();
+  for await (const row of connection.stream(
+    { sql: "PRAGMA foreign_key_check" },
+    signal === void 0 ? {} : { signal }
+  )) {
+    total++;
+    const table = toText(row.table) ?? "?";
+    byTable.set(table, (byTable.get(table) ?? 0) + 1);
+    if (found.length < MAX_REPORTED_FOREIGN_KEY_VIOLATIONS) {
+      found.push({
+        code: "foreign-key-violation",
+        message: `Row ${toText(row.rowid) ?? "(no rowid)"} of table "${table}" references a missing row in "${toText(row.parent) ?? "?"}" (foreign key #${toText(row.fkid) ?? "?"}).`
+      });
+    }
+  }
+  if (total > found.length) {
+    found.push({
+      code: "foreign-key-violation",
+      message: `${total} foreign-key violations in total: ${[...byTable].map(([table, count]) => `${table} (${count})`).join(", ")}.`
+    });
+  }
+  return found;
+}
+function toStatementError(connection, statement, error) {
+  const described = connection.describeError?.(error);
+  const message = redactSecrets(
+    described?.message ?? (error instanceof Error ? error.message : String(error))
+  );
+  const sqliteError = described ? { ...described, message: redactSecrets(described.message) } : void 0;
+  const executionError = new RestoreExecutionError(
+    statement.statementIndex,
+    statement.location,
+    safeSqlPreview(statement.sql),
+    message,
+    sqliteError,
+    { cause: error }
+  );
+  return {
+    statementIndex: executionError.statementIndex,
+    location: executionError.location,
+    sqlPreview: executionError.sqlPreview,
+    message: executionError.message,
+    ...executionError.sqliteError === void 0 ? {} : { sqliteError: executionError.sqliteError }
+  };
+}
+
+// src/api/dump.ts
+async function dumpSqlite(connectionInput, options, output, onProgress, signal) {
+  onProgress?.({ phase: "connecting" });
+  const acquired = await acquireSqliteConnection(connectionInput, signal);
+  const session = await (async () => {
+    onProgress?.({ phase: "starting-snapshot" });
+    try {
+      return await beginSqliteDumpSession(
+        acquired.connection,
+        options.consistency === void 0 ? {} : { consistency: options.consistency },
+        signal
+      );
+    } catch (error) {
+      await acquired.release();
+      throw error;
+    }
+  })();
+  try {
+    onProgress?.({ phase: "introspecting" });
+    const introspection = await introspectSqlite(
+      acquired.connection,
+      options.schemaName === void 0 ? {} : { schemaName: options.schemaName },
+      signal
+    );
+    onProgress?.({
+      phase: "detecting-version",
+      message: introspection.version.versionString,
+      schemaName: introspection.database.schemaName
+    });
+    const mode = options.mode ?? "full";
+    const selection = normalizeDumpSelection(options.selection);
+    const archive = inspectDumpArchive(introspection.database, {
+      mode,
+      selection,
+      ...options.objectKinds === void 0 ? {} : { objectKinds: options.objectKinds }
+    });
+    onProgress?.({ phase: "planning-archive", objectsTotal: archive.entries.length });
+    if (!archive.valid) {
+      throw new SqliteDumperError(
+        "invalid-archive",
+        "Archive planning failed; inspect the diagnostics, cycles and unsatisfiedDependencies returned by inspectDumpArchive for details"
+      );
+    }
+    const writer = new StreamDumpWriter(output);
+    const tablesByName = new Map(
+      introspection.database.tables.map((table) => [foldSqliteName(table.name), table])
+    );
+    let rowsExported = 0;
+    let statementsWritten = 0;
+    const dataWarnings = [];
+    const onTableData = async (entry) => {
+      const table = tablesByName.get(foldSqliteName(entry.name));
+      if (!table) {
+        return false;
+      }
+      const result = await exportTableDataAsInserts({
+        connection: acquired.connection,
+        schemaName: introspection.database.schemaName,
+        table,
+        writer,
+        encoding: introspection.database.encoding,
+        ...entry.systemRowFilter === void 0 ? {} : { systemRowFilter: entry.systemRowFilter },
+        ...options.dataExport === void 0 ? {} : { options: options.dataExport },
+        ...signal === void 0 ? {} : { signal },
+        ...onProgress === void 0 ? {} : { onProgress }
+      });
+      rowsExported += result.rowsExported;
+      statementsWritten += result.statementsWritten;
+      dataWarnings.push(...result.warnings);
+      if (result.cancelled) {
+        throw new DOMException("The operation was aborted.", "AbortError");
+      }
+      return true;
+    };
+    const renderResult = await renderPlainSql({
+      database: introspection.database,
+      archive,
+      writer,
+      mode,
+      sourceVersion: introspection.version,
+      ...options.render === void 0 ? {} : { options: options.render },
+      ...signal === void 0 ? {} : { signal },
+      ...onProgress === void 0 ? {} : { onProgress },
+      onTableData
+    });
+    onProgress?.({ phase: "finalizing", bytesWritten: renderResult.bytesWritten });
+    const sessionWarnings = session.joinedExistingTransaction ? [
+      {
+        severity: "info",
+        code: "dump-joined-caller-transaction",
+        message: "The connection was already inside a transaction, so the dump was read within it and includes that transaction's uncommitted changes."
+      }
+    ] : [];
+    return {
+      bytesWritten: renderResult.bytesWritten,
+      renderedDumpIds: renderResult.renderedDumpIds,
+      skippedDumpIds: renderResult.skippedDumpIds,
+      warnings: [
+        ...introspection.diagnostics,
+        ...archive.diagnostics,
+        ...sessionWarnings,
+        ...renderResult.warnings,
+        ...dedupeDiagnostics(dataWarnings)
+      ],
+      cancelled: renderResult.cancelled,
+      rowsExported,
+      statementsWritten
+    };
+  } finally {
+    await session.finish();
+    await acquired.release();
+  }
+}
+function dedupeDiagnostics(diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  return diagnostics.filter((diagnostic) => {
+    const key = `${diagnostic.code}\0${diagnostic.message}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BufferDumpWriter,
+  COMPLETE_TRANSITIONS,
+  CompleteToken,
+  DEFENSIVE_WARNING_COMMENT,
+  InvalidTextEncodingError,
+  MalformedSqlDumpError,
+  OperationCancelledError,
+  RestoreError,
+  RestoreExecutionError,
+  RestoreSessionState,
+  SEQUENCE_TABLE_NAME,
+  SESSION_GUARD_FOOTER,
+  SESSION_GUARD_HEADER,
+  SQLITE_KEYWORD_COUNT,
+  SqlChunkBuilder,
+  SqlParseError,
+  SqlStatementParser,
+  SqliteDumperError,
+  StatementTooLargeError,
+  StreamDumpWriter,
+  UNSUPPORTED_FEATURES,
+  UnsupportedClientCommandError,
+  WRITABLE_SCHEMA_OFF,
+  WRITABLE_SCHEMA_ON,
+  acquireSqliteConnection,
+  assignDumpSection,
+  beginSqliteDumpSession,
+  checkTargetCompatibility,
+  classifyWord,
+  columnValueSelect,
+  completeTransition,
+  createArchiveIdentity,
+  createCanonicalIdentity,
+  createDumpId,
+  declaresAutoincrement,
+  decodeStatementBytes,
+  describeStatement,
+  detectSqliteCapabilities,
+  detectSqliteVersion,
+  detectTargetCapabilities,
+  dumpSectionPriority,
+  dumpSqlite,
+  executeStatement,
+  exportTableDataAsInserts,
+  foldSqliteName,
+  insertableColumns,
+  inspectDumpArchive,
+  introspectSqlite,
+  isAbortError,
+  isCompleteStatement,
+  isIdentifierCharCode,
+  isIndexSelected,
+  isSchemaTableName,
+  isSqliteConnectionSource,
+  isSqliteDump,
+  isSqliteKeyword,
+  isStatisticsTableName,
+  isTableDataExcluded,
+  isTableSelected,
+  isTriggerSelected,
+  isTruthyPragmaValue,
+  isViewSelected,
+  maskSqlLiterals,
+  needsIdentifierQuoting,
+  normalizeDumpSelection,
+  parseSqlStatements,
+  parseSqliteVersion,
+  parseTableOptions,
+  parseVirtualTableModule,
+  preflightRestore,
+  preservableRowidName,
+  quoteIdentifier,
+  quoteIdentifierIfNeeded,
+  quoteQualifiedIdentifier,
+  quoteStringLiteral,
+  redactSecrets,
+  renderBlobLiteral,
+  renderColumnLiteral,
+  renderDatabaseSettings,
+  renderDrop,
+  renderEscapedStringLiteral,
+  renderPlainSql,
+  renderQuotedStringLiteral,
+  renderSchemaLine,
+  renderSchemaObject,
+  renderSystemTablePrelude,
+  renderTextLiteral,
+  renderVirtualTable,
+  resolvePlainSqlRenderOptions,
+  restoreSqlDump,
+  safeSqlPreview,
+  streamSqlStatements,
+  streamWithParser,
+  tableGroupPriority,
+  throwIfAborted,
+  toAsciiLowerCase,
+  toAsciiUpperCase,
+  toByteStringChunks,
+  toNumber,
+  toText,
+  unsupportedFeatureDiagnostics
+});
+//# sourceMappingURL=index.cjs.map