@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/chunk-MBPZXTJA.js

@@ -0,0 +1,2428 @@
+#!/usr/bin/env node
+import {
+  EDGE_SQLITE_APPLICATION_ID,
+  LOCAL_SQLITE_APPLICATION_ID,
+  SQLITE_DATABASE_SCHEMA_VERSION,
+  SQLiteBridgeStore,
+  SQLiteDatabaseContractError,
+  assertLocalAuthorityDatabase,
+  identifySqliteDatabase,
+  isSupportedLocalSqliteSchemaContract,
+  sqliteSchemaContractHash,
+  verifySqliteHealth
+} from "./chunk-5GMB3A77.js";
+import {
+  preparePrivateFileLocation,
+  preparePrivateSqliteLocation,
+  securePrivatePath,
+  securePrivateSqliteFiles,
+  verifyPrivatePathAccess
+} from "./chunk-NCO7RLBM.js";
+import {
+  NATIVE_DR_ADVISORY_LOCK_KEY,
+  rowIsolationReady
+} from "./chunk-45BZGB77.js";
+
+// src/native-dr-bundle.ts
+import { createHash } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  openSync,
+  readSync,
+  writeSync
+} from "fs";
+import { dirname, resolve } from "path";
+var MAGIC = Buffer.from("AGENT-BRIDGE-DR!", "ascii");
+var HEADER_BYTES = MAGIC.length + 2 + 4;
+var FRAME_BYTES = 2 + 8 + 32;
+var CHUNK_BYTES = 64 * 1024;
+var MAX_MANIFEST_BYTES = 64 * 1024;
+var NATIVE_DR_MAX_BUNDLE_BYTES = 64 * 1024 * 1024 * 1024;
+var MAX_ENTRIES = 16;
+var NATIVE_DR_FORMAT = "agent-bridge-native-dr";
+var NATIVE_DR_VERSION = 1;
+var NativeDrBundleError = class extends Error {
+};
+function assertString(value, label) {
+  if (value.includes("\0")) throw new NativeDrBundleError(`${label} contains U+0000`);
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) throw new NativeDrBundleError(`${label} contains an unpaired surrogate`);
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) throw new NativeDrBundleError(`${label} contains an unpaired surrogate`);
+  }
+}
+function canonical(value) {
+  if (typeof value === "string") {
+    assertString(value, "DR manifest string");
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) throw new NativeDrBundleError("DR manifest contains a non-finite number");
+  if (value === void 0 || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new NativeDrBundleError("DR manifest contains an unsupported value");
+  }
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => {
+    assertString(key, "DR manifest field");
+    return `${JSON.stringify(key)}:${canonical(record[key])}`;
+  }).join(",")}}`;
+}
+var POSTGRES_SCHEMA_FIELDS = [
+  "databaseName",
+  "serverVersionNum",
+  "serverMajor",
+  "schemaVersion",
+  "migrations",
+  "tableCounts",
+  "excludedDataTables",
+  "pgDumpVersion",
+  "roleInventorySha256",
+  "claimedDeliveryCount",
+  "readinessAttestations"
+];
+var POSTGRES_EXCLUDED_DATA = [
+  "agent_bridge.agent_instances",
+  "agent_bridge.rate_limit_buckets",
+  "agent_bridge.request_authorities",
+  "agent_bridge.archive_transaction_authorizations"
+];
+function validateSchema(kind, value) {
+  if (kind === "sqlite") {
+    const schema2 = exactObject(value, ["applicationId", "schemaContractSha256", "userVersion"], "DR SQLite schema");
+    if (!Number.isSafeInteger(schema2.applicationId) || !Number.isSafeInteger(schema2.userVersion) || typeof schema2.schemaContractSha256 !== "string" || !/^[a-f0-9]{64}$/.test(schema2.schemaContractSha256)) throw new NativeDrBundleError("DR SQLite schema metadata is invalid");
+    return schema2;
+  }
+  const schema = exactObject(value, POSTGRES_SCHEMA_FIELDS, "DR PostgreSQL schema");
+  if (typeof schema.databaseName !== "string" || !schema.databaseName || schema.databaseName.length > 128 || !Number.isSafeInteger(schema.serverVersionNum) || Number(schema.serverVersionNum) < 1e5 || !Number.isSafeInteger(schema.serverMajor) || Number(schema.serverMajor) < 10 || !Number.isSafeInteger(schema.schemaVersion) || Number(schema.schemaVersion) < 1 || typeof schema.pgDumpVersion !== "string" || !schema.pgDumpVersion || schema.pgDumpVersion.length > 128 || typeof schema.roleInventorySha256 !== "string" || !/^[a-f0-9]{64}$/.test(schema.roleInventorySha256) || typeof schema.claimedDeliveryCount !== "string" || !/^(0|[1-9][0-9]*)$/.test(schema.claimedDeliveryCount)) {
+    throw new NativeDrBundleError("DR PostgreSQL schema metadata is invalid");
+  }
+  assertString(schema.databaseName, "DR database name");
+  assertString(schema.pgDumpVersion, "DR pg_dump version");
+  if (!Array.isArray(schema.migrations) || schema.migrations.length > 1e4) throw new NativeDrBundleError("DR PostgreSQL migration inventory is invalid");
+  let priorVersion = 0;
+  for (const raw of schema.migrations) {
+    const migration = exactObject(raw, ["checksum", "name", "version"], "DR migration");
+    if (!Number.isSafeInteger(migration.version) || Number(migration.version) <= priorVersion || typeof migration.name !== "string" || !/^[a-z0-9][a-z0-9_]{0,127}$/.test(migration.name) || typeof migration.checksum !== "string" || !/^[a-f0-9]{64}$/.test(migration.checksum)) {
+      throw new NativeDrBundleError("DR PostgreSQL migration inventory is invalid");
+    }
+    priorVersion = Number(migration.version);
+  }
+  if (!schema.tableCounts || typeof schema.tableCounts !== "object" || Array.isArray(schema.tableCounts)) throw new NativeDrBundleError("DR PostgreSQL table counts are invalid");
+  for (const [table, count] of Object.entries(schema.tableCounts)) {
+    if (!/^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*$/.test(table) || typeof count !== "string" || !/^(0|[1-9][0-9]*)$/.test(count)) {
+      throw new NativeDrBundleError("DR PostgreSQL table counts are invalid");
+    }
+  }
+  if (!Array.isArray(schema.excludedDataTables) || schema.excludedDataTables.length !== POSTGRES_EXCLUDED_DATA.length || schema.excludedDataTables.some((name, index) => name !== POSTGRES_EXCLUDED_DATA[index])) {
+    throw new NativeDrBundleError("DR PostgreSQL excluded-data inventory is invalid");
+  }
+  const readiness = exactObject(schema.readinessAttestations, [
+    "ownerControlSha256",
+    "portableArchiveSha256",
+    "rowIsolationSha256",
+    "securitySchemaSha256"
+  ], "DR PostgreSQL readiness attestations");
+  if (Object.values(readiness).some((value2) => typeof value2 !== "string" || !/^[a-f0-9]{64}$/.test(value2))) {
+    throw new NativeDrBundleError("DR PostgreSQL readiness attestations are invalid");
+  }
+  return schema;
+}
+function expectedEntries(kind) {
+  return kind === "sqlite" ? ["sqlite/database.sqlite3"] : ["postgres/database.dump", "postgres/roles.json"];
+}
+function sameFile(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function writeAll(descriptor, bytes) {
+  let offset = 0;
+  while (offset < bytes.length) offset += writeSync(descriptor, bytes, offset, bytes.length - offset);
+}
+function exactObject(value, fields, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new NativeDrBundleError(`${label} must be an object`);
+  const record = value;
+  const actual = Object.keys(record).sort();
+  const expected = [...fields].sort();
+  if (actual.length !== expected.length || actual.some((field, index) => field !== expected[index])) {
+    throw new NativeDrBundleError(`${label} has unexpected fields`);
+  }
+  return record;
+}
+function parseManifest(bytes) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new NativeDrBundleError("DR manifest is not valid UTF-8");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new NativeDrBundleError("DR manifest is not valid JSON");
+  }
+  if (canonical(parsed) !== text) throw new NativeDrBundleError("DR manifest is not canonical JSON");
+  const manifest = exactObject(parsed, ["backupId", "createdAt", "entries", "format", "kind", "schema", "version"], "DR manifest");
+  if (manifest.format !== NATIVE_DR_FORMAT || manifest.version !== NATIVE_DR_VERSION || manifest.kind !== "sqlite" && manifest.kind !== "postgres") {
+    throw new NativeDrBundleError("DR bundle format is unsupported");
+  }
+  if (typeof manifest.backupId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(manifest.backupId)) {
+    throw new NativeDrBundleError("DR backup ID is invalid");
+  }
+  let canonicalTimestamp = "";
+  try {
+    canonicalTimestamp = typeof manifest.createdAt === "string" ? new Date(manifest.createdAt).toISOString() : "";
+  } catch {
+  }
+  if (typeof manifest.createdAt !== "string" || canonicalTimestamp !== manifest.createdAt) {
+    throw new NativeDrBundleError("DR creation timestamp is invalid");
+  }
+  if (!Array.isArray(manifest.entries) || !manifest.entries.length || manifest.entries.length > MAX_ENTRIES) throw new NativeDrBundleError("DR entry set is invalid");
+  let previous = "";
+  for (const rawEntry of manifest.entries) {
+    const entry = exactObject(rawEntry, ["length", "name", "sha256"], "DR entry");
+    if (typeof entry.name !== "string" || !/^[a-z0-9][a-z0-9/_.-]{0,255}$/.test(entry.name) || entry.name.split("/").includes("..") || entry.name <= previous || !Number.isSafeInteger(entry.length) || Number(entry.length) < 1 || Number(entry.length) > NATIVE_DR_MAX_BUNDLE_BYTES || typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256)) {
+      throw new NativeDrBundleError("DR entry metadata is invalid");
+    }
+    previous = entry.name;
+  }
+  const allowedEntries = expectedEntries(manifest.kind);
+  if (manifest.entries.length !== allowedEntries.length || manifest.entries.some((entry, index) => entry.name !== allowedEntries[index])) throw new NativeDrBundleError("DR entries do not match the provider kind");
+  validateSchema(manifest.kind, manifest.schema);
+  return parsed;
+}
+function hashFile(descriptor, identity) {
+  const hash = createHash("sha256");
+  const chunk = Buffer.allocUnsafe(CHUNK_BYTES);
+  let position = 0;
+  while (position < identity.size) {
+    const read = readSync(descriptor, chunk, 0, Math.min(chunk.length, identity.size - position), position);
+    if (read <= 0) throw new NativeDrBundleError("DR source ended before its recorded size");
+    hash.update(chunk.subarray(0, read));
+    position += read;
+  }
+  if (!sameFile(identity, fstatSync(descriptor))) throw new NativeDrBundleError("DR source changed while hashing");
+  return hash.digest("hex");
+}
+function openInput(entry) {
+  const path = resolve(entry.path);
+  verifyPrivatePathAccess(dirname(path), "directory");
+  verifyPrivatePathAccess(path, "file");
+  const before = lstatSync(path);
+  const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+  const descriptor = openSync(path, constants.O_RDONLY | noFollow);
+  try {
+    const identity = fstatSync(descriptor);
+    const named = lstatSync(path);
+    if (!identity.isFile() || before.isSymbolicLink() || !sameFile(before, identity) || !sameFile(named, identity) || identity.size < 1 || identity.size > NATIVE_DR_MAX_BUNDLE_BYTES) throw new NativeDrBundleError("DR source is not a stable regular file");
+    return { descriptor, identity, name: entry.name, path };
+  } catch (error) {
+    closeSync(descriptor);
+    throw error;
+  }
+}
+function validateNativeDrAggregateSize(entryBytes, framingBytes = 0) {
+  let total = framingBytes;
+  for (const bytes of entryBytes) {
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || total > NATIVE_DR_MAX_BUNDLE_BYTES - bytes) {
+      throw new NativeDrBundleError("DR bundle exceeds its aggregate size limit");
+    }
+    total += bytes;
+  }
+  return total;
+}
+function writeNativeDrBundle(outputDescriptor, input, outputPath, hooks = {}) {
+  if (!input.entries.length || input.entries.length > MAX_ENTRIES) throw new NativeDrBundleError("DR entry set is invalid");
+  const names = input.entries.map((entry) => entry.name);
+  if (names.some((name, index) => index > 0 && name <= names[index - 1])) throw new NativeDrBundleError("DR entries must be uniquely ordered by name");
+  const allowedEntries = expectedEntries(input.kind);
+  if (names.length !== allowedEntries.length || names.some((name, index) => name !== allowedEntries[index])) {
+    throw new NativeDrBundleError("DR entries do not match the provider kind");
+  }
+  validateSchema(input.kind, input.schema);
+  const sources = [];
+  try {
+    for (const entry of input.entries) {
+      const opened = openInput(entry);
+      sources.push({ ...opened, sha256: hashFile(opened.descriptor, opened.identity) });
+    }
+    hooks.afterHash?.();
+    const manifest = {
+      backupId: input.backupId,
+      createdAt: input.createdAt,
+      entries: sources.map((source) => ({ length: source.identity.size, name: source.name, sha256: source.sha256 })),
+      format: NATIVE_DR_FORMAT,
+      kind: input.kind,
+      schema: input.schema,
+      version: NATIVE_DR_VERSION
+    };
+    const manifestBytes = Buffer.from(canonical(manifest), "utf8");
+    if (manifestBytes.length > MAX_MANIFEST_BYTES) throw new NativeDrBundleError("DR manifest exceeds 64 KiB");
+    parseManifest(manifestBytes);
+    const output = resolve(outputPath);
+    verifyPrivatePathAccess(dirname(output), "directory");
+    verifyPrivatePathAccess(output, "file");
+    const openedOutput = fstatSync(outputDescriptor);
+    const namedOutput = lstatSync(output);
+    if (!openedOutput.isFile() || namedOutput.isSymbolicLink() || !sameFile(openedOutput, namedOutput) || openedOutput.size !== 0) {
+      throw new NativeDrBundleError("DR output file identity changed during staging");
+    }
+    validateNativeDrAggregateSize(
+      sources.map((source) => source.identity.size),
+      HEADER_BYTES + manifestBytes.length + sources.reduce((total, source) => total + FRAME_BYTES + Buffer.byteLength(source.name), 0)
+    );
+    const header = Buffer.alloc(HEADER_BYTES);
+    MAGIC.copy(header);
+    header.writeUInt16BE(NATIVE_DR_VERSION, MAGIC.length);
+    header.writeUInt32BE(manifestBytes.length, MAGIC.length + 2);
+    writeAll(outputDescriptor, header);
+    writeAll(outputDescriptor, manifestBytes);
+    for (const source of sources) {
+      const name = Buffer.from(source.name, "utf8");
+      const frame = Buffer.alloc(FRAME_BYTES);
+      frame.writeUInt16BE(name.length, 0);
+      frame.writeBigUInt64BE(BigInt(source.identity.size), 2);
+      Buffer.from(source.sha256, "hex").copy(frame, 10);
+      writeAll(outputDescriptor, frame);
+      writeAll(outputDescriptor, name);
+      const streamedHash = createHash("sha256");
+      const chunk = Buffer.allocUnsafe(CHUNK_BYTES);
+      let position = 0;
+      while (position < source.identity.size) {
+        const read = readSync(source.descriptor, chunk, 0, Math.min(chunk.length, source.identity.size - position), position);
+        if (read <= 0) throw new NativeDrBundleError("DR source ended while streaming");
+        const bytes = chunk.subarray(0, read);
+        streamedHash.update(bytes);
+        writeAll(outputDescriptor, bytes);
+        position += read;
+      }
+      if (streamedHash.digest("hex") !== source.sha256) throw new NativeDrBundleError("DR source changed between hashing and bundling");
+      if (!sameFile(source.identity, fstatSync(source.descriptor)) || !sameFile(source.identity, lstatSync(source.path))) {
+        throw new NativeDrBundleError("DR source changed while bundling");
+      }
+    }
+    fsyncSync(outputDescriptor);
+    return manifest;
+  } finally {
+    for (const source of sources) closeSync(source.descriptor);
+  }
+}
+var NativeDrBundleReader = class {
+  constructor(path) {
+    this.closed = false;
+    this.path = resolve(path);
+    verifyPrivatePathAccess(dirname(this.path), "directory");
+    verifyPrivatePathAccess(this.path, "file");
+    const before = lstatSync(this.path);
+    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    this.descriptor = openSync(this.path, constants.O_RDONLY | noFollow);
+    try {
+      this.identity = fstatSync(this.descriptor);
+      const after = lstatSync(this.path);
+      if (!this.identity.isFile() || before.isSymbolicLink() || !sameFile(before, this.identity) || !sameFile(after, this.identity) || this.identity.size < HEADER_BYTES + FRAME_BYTES + 1 || this.identity.size > NATIVE_DR_MAX_BUNDLE_BYTES) {
+        throw new NativeDrBundleError("DR bundle is not a stable regular file");
+      }
+    } catch (error) {
+      closeSync(this.descriptor);
+      throw error;
+    }
+  }
+  readExact(position, length, hash) {
+    const output = Buffer.allocUnsafe(length);
+    let offset = 0;
+    while (offset < length) {
+      const read = readSync(this.descriptor, output, offset, length - offset, position + offset);
+      if (read <= 0) throw new NativeDrBundleError("DR bundle ended unexpectedly");
+      offset += read;
+    }
+    hash.update(output);
+    return output;
+  }
+  inspect(output) {
+    if (this.closed) throw new NativeDrBundleError("DR bundle is closed");
+    const bundleHash = createHash("sha256");
+    let position = 0;
+    const header = this.readExact(position, HEADER_BYTES, bundleHash);
+    position += header.length;
+    if (!header.subarray(0, MAGIC.length).equals(MAGIC) || header.readUInt16BE(MAGIC.length) !== NATIVE_DR_VERSION) {
+      throw new NativeDrBundleError("DR bundle header is unsupported");
+    }
+    const manifestLength = header.readUInt32BE(MAGIC.length + 2);
+    if (manifestLength < 1 || manifestLength > MAX_MANIFEST_BYTES) throw new NativeDrBundleError("DR manifest size is invalid");
+    const manifest = parseManifest(this.readExact(position, manifestLength, bundleHash));
+    position += manifestLength;
+    for (const expected of manifest.entries) {
+      const frame = this.readExact(position, FRAME_BYTES, bundleHash);
+      position += frame.length;
+      const nameLength = frame.readUInt16BE(0);
+      const length = Number(frame.readBigUInt64BE(2));
+      const digest = frame.subarray(10).toString("hex");
+      if (!Number.isSafeInteger(length) || length !== expected.length || digest !== expected.sha256) {
+        throw new NativeDrBundleError("DR entry frame does not match the manifest");
+      }
+      const name = this.readExact(position, nameLength, bundleHash);
+      position += nameLength;
+      let decoded;
+      try {
+        decoded = new TextDecoder("utf-8", { fatal: true }).decode(name);
+      } catch {
+        throw new NativeDrBundleError("DR entry name is not valid UTF-8");
+      }
+      if (decoded !== expected.name) throw new NativeDrBundleError("DR entry name does not match the manifest");
+      const outputDescriptor = output?.(expected);
+      const entryHash = createHash("sha256");
+      const chunk = Buffer.allocUnsafe(CHUNK_BYTES);
+      let remaining = length;
+      while (remaining > 0) {
+        const requested = Math.min(chunk.length, remaining);
+        const read = readSync(this.descriptor, chunk, 0, requested, position);
+        if (read <= 0) throw new NativeDrBundleError("DR entry ended unexpectedly");
+        const bytes = chunk.subarray(0, read);
+        bundleHash.update(bytes);
+        entryHash.update(bytes);
+        if (outputDescriptor !== void 0) writeAll(outputDescriptor, bytes);
+        position += read;
+        remaining -= read;
+      }
+      if (entryHash.digest("hex") !== digest) throw new NativeDrBundleError("DR entry digest verification failed");
+    }
+    if (position !== this.identity.size) throw new NativeDrBundleError("DR bundle has trailing bytes");
+    if (!sameFile(this.identity, fstatSync(this.descriptor)) || !sameFile(this.identity, lstatSync(this.path))) {
+      throw new NativeDrBundleError("DR bundle changed while reading");
+    }
+    return { manifest, bundleSha256: bundleHash.digest("hex"), bundleBytes: this.identity.size };
+  }
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      closeSync(this.descriptor);
+    }
+  }
+};
+
+// src/postgres-native-dr.ts
+import { spawn } from "child_process";
+import { createHash as createHash2, randomUUID } from "crypto";
+import {
+  accessSync,
+  closeSync as closeSync2,
+  constants as constants2,
+  existsSync,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync2,
+  mkdtempSync,
+  openSync as openSync2,
+  readSync as readSync2,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { delimiter, join, resolve as resolve2 } from "path";
+import pg from "pg";
+
+// src/bounded-tool-output.ts
+function createBoundedToolOutput(maximumBytes) {
+  if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 0) throw new Error("tool output capture limit is invalid");
+  const chunks = [];
+  let capturedBytes = 0;
+  let truncated = false;
+  return {
+    push(chunk) {
+      const remaining = maximumBytes - capturedBytes;
+      if (remaining > 0) {
+        const captured = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
+        chunks.push(captured);
+        capturedBytes += captured.length;
+      }
+      if (chunk.length > remaining) truncated = true;
+    },
+    read() {
+      return { bytes: Buffer.concat(chunks, capturedBytes), truncated };
+    }
+  };
+}
+
+// src/postgres-native-dr.ts
+var POSTGRES_NATIVE_DR_ROLE_SCHEMA = "agent-bridge.postgres-native-dr-roles";
+var POSTGRES_NATIVE_DR_ROLE_VERSION = 1;
+var POSTGRES_NATIVE_DR_SERVICE = "agent_bridge_dr";
+var POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES = [
+  "agent_bridge.agent_instances",
+  "agent_bridge.rate_limit_buckets",
+  "agent_bridge.request_authorities",
+  "agent_bridge.archive_transaction_authorizations"
+];
+var SSL_PARAMETERS = /* @__PURE__ */ new Set([
+  "channel_binding",
+  "sslcert",
+  "sslcrl",
+  "sslcrldir",
+  "sslkey",
+  "sslmode",
+  "sslrootcert",
+  "sslsni"
+]);
+var DERIVED_ROLE = /^agent_bridge_(?:runtime|data_owner|context_reader|event_writer|control_owner|control_operator|control_auditor|archive_operator)_[0-9a-f]{16}$/;
+var ROLE_NAME = /^[^\u0000-\u001f\u007f]{1,63}$/u;
+function validPostgresIdentifier(value) {
+  return value !== "PUBLIC" && !value.includes(":") && ROLE_NAME.test(value) && Buffer.byteLength(value, "utf8") <= 63;
+}
+var PostgresNativeDrError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "PostgresNativeDrError";
+  }
+};
+function assertRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+}
+function exactKeys(value, expected, label) {
+  const expectedSet = new Set(expected);
+  const unexpected = Object.keys(value).filter((key) => !expectedSet.has(key));
+  const missing = expected.filter((key) => !(key in value));
+  if (unexpected.length > 0) throw new Error(`${label} has unexpected fields: ${unexpected.join(", ")}`);
+  if (missing.length > 0) throw new Error(`${label} is missing fields: ${missing.join(", ")}`);
+}
+function assertSafeText(value, label) {
+  if (value.length === 0 || /[\u0000\r\n]/u.test(value)) throw new Error(`${label} is invalid`);
+}
+function serviceValue(value, label) {
+  assertSafeText(value, label);
+  if (value.trim() !== value) throw new Error(`${label} cannot begin or end with whitespace`);
+  return value;
+}
+function pgpassValue(value) {
+  assertSafeText(value, "PostgreSQL credential component");
+  return value.split("\\").join("\\\\").split(":").join("\\:");
+}
+function createPostgresDrLibpqFiles(connectionUrl, directory) {
+  let url;
+  try {
+    url = new URL(connectionUrl);
+  } catch {
+    throw new Error("PostgreSQL disaster recovery URL is invalid");
+  }
+  if (url.protocol !== "postgresql:" && url.protocol !== "postgres:") {
+    throw new Error("PostgreSQL disaster recovery URL must use postgres or postgresql");
+  }
+  if (!url.hostname || !url.username || !url.pathname || url.pathname === "/") {
+    throw new Error("PostgreSQL disaster recovery URL must include host, user, and database");
+  }
+  for (const key of url.searchParams.keys()) {
+    if (!SSL_PARAMETERS.has(key)) throw new Error(`unsupported PostgreSQL connection parameter: ${key}`);
+  }
+  const duplicateKeys = [...new Set(url.searchParams.keys())].filter((key) => url.searchParams.getAll(key).length !== 1);
+  if (duplicateKeys.length > 0) throw new Error(`duplicate PostgreSQL connection parameter: ${duplicateKeys[0]}`);
+  const targetDirectory = resolve2(directory);
+  securePrivatePath(targetDirectory, "directory");
+  verifyPrivatePathAccess(targetDirectory, "directory");
+  const serviceFile = resolve2(targetDirectory, "pg_service.conf");
+  const passFile = resolve2(targetDirectory, "pgpass");
+  let database2;
+  let user;
+  let password;
+  try {
+    database2 = decodeURIComponent(url.pathname.slice(1));
+    user = decodeURIComponent(url.username);
+    password = decodeURIComponent(url.password);
+  } catch {
+    throw new Error("PostgreSQL disaster recovery URL contains invalid percent encoding");
+  }
+  const host = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+  const port = url.port || "5432";
+  const serviceLines = [
+    `[${POSTGRES_NATIVE_DR_SERVICE}]`,
+    `host=${serviceValue(host, "PostgreSQL host")}`,
+    `port=${serviceValue(port, "PostgreSQL port")}`,
+    `dbname=${serviceValue(database2, "PostgreSQL database")}`,
+    `user=${serviceValue(user, "PostgreSQL user")}`
+  ];
+  for (const [key, value] of [...url.searchParams.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    serviceLines.push(`${key}=${serviceValue(value, `PostgreSQL ${key}`)}`);
+  }
+  writeFileSync(serviceFile, `${serviceLines.join("\n")}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+  writeFileSync(passFile, `${[
+    pgpassValue(host),
+    pgpassValue(port),
+    pgpassValue(database2),
+    pgpassValue(user),
+    pgpassValue(password)
+  ].join(":")}
+`, { encoding: "utf8", mode: 384, flag: "wx" });
+  securePrivatePath(serviceFile, "file");
+  securePrivatePath(passFile, "file");
+  verifyPrivatePathAccess(serviceFile, "file");
+  verifyPrivatePathAccess(passFile, "file");
+  return {
+    serviceName: POSTGRES_NATIVE_DR_SERVICE,
+    serviceFile,
+    passFile,
+    environment: {
+      LC_ALL: "C",
+      PGAPPNAME: "agent-bridge-native-dr",
+      PGPASSFILE: passFile,
+      PGSERVICE: POSTGRES_NATIVE_DR_SERVICE,
+      PGSERVICEFILE: serviceFile
+    }
+  };
+}
+function buildPgDumpArgs(outputPath, snapshot, serviceName = POSTGRES_NATIVE_DR_SERVICE) {
+  assertSafeText(outputPath, "PostgreSQL dump path");
+  assertSafeText(snapshot, "PostgreSQL snapshot");
+  assertSafeText(serviceName, "PostgreSQL service name");
+  return [
+    "--format=custom",
+    `--file=${outputPath}`,
+    "--schema=agent_bridge",
+    "--no-tablespaces",
+    `--snapshot=${snapshot}`,
+    ...POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES.map((table) => `--exclude-table-data=${table}`),
+    `--dbname=service=${serviceName}`
+  ];
+}
+function buildPgRestoreArgs(inputPath, serviceName = POSTGRES_NATIVE_DR_SERVICE) {
+  if (inputPath !== void 0) assertSafeText(inputPath, "PostgreSQL dump path");
+  assertSafeText(serviceName, "PostgreSQL service name");
+  return [
+    "--exit-on-error",
+    "--single-transaction",
+    "--no-tablespaces",
+    "--schema=agent_bridge",
+    `--dbname=service=${serviceName}`,
+    ...inputPath === void 0 ? [] : [inputPath]
+  ];
+}
+function buildPgRestoreListArgs(inputPath) {
+  if (inputPath !== void 0) assertSafeText(inputPath, "PostgreSQL dump path");
+  return inputPath === void 0 ? ["--list"] : ["--list", inputPath];
+}
+function buildPgRestoreSchemaAclArgs(inputPath, listPath, serviceName = POSTGRES_NATIVE_DR_SERVICE) {
+  if (inputPath !== void 0) assertSafeText(inputPath, "PostgreSQL dump path");
+  assertSafeText(listPath, "PostgreSQL restore list path");
+  assertSafeText(serviceName, "PostgreSQL service name");
+  return [
+    "--exit-on-error",
+    "--single-transaction",
+    "--no-tablespaces",
+    `--use-list=${listPath}`,
+    `--dbname=service=${serviceName}`,
+    ...inputPath === void 0 ? [] : [inputPath]
+  ];
+}
+var POSTGRES_TOC_DESCRIPTORS = [
+  "MATERIALIZED VIEW DATA",
+  "SEQUENCE OWNED BY",
+  "SECURITY LABEL",
+  "CHECK CONSTRAINT",
+  "PUBLICATION TABLE",
+  "MATERIALIZED VIEW",
+  "SEQUENCE SET",
+  "TABLE ATTACH",
+  "ROW SECURITY",
+  "DEFAULT ACL",
+  "TABLE DATA",
+  "FK CONSTRAINT",
+  "OPERATOR CLASS",
+  "OPERATOR FAMILY",
+  "FOREIGN TABLE",
+  "BLOB COMMENTS",
+  "BLOB ACL",
+  "PROCEDURE",
+  "AGGREGATE",
+  "COLLATION",
+  "CONVERSION",
+  "CONSTRAINT",
+  "FUNCTION",
+  "OPERATOR",
+  "SEQUENCE",
+  "TRIGGER",
+  "POLICY",
+  "COMMENT",
+  "DEFAULT",
+  "SCHEMA",
+  "TABLE",
+  "TYPE",
+  "DOMAIN",
+  "INDEX",
+  "RULE",
+  "VIEW",
+  "ACL"
+];
+var POSTGRES_TOC_MAX_BYTES = 16 * 1024 * 1024;
+function validatePostgresDumpToc(text) {
+  if (Buffer.byteLength(text, "utf8") > POSTGRES_TOC_MAX_BYTES) {
+    throw new PostgresNativeDrError("PG_DUMP_TOC_INVALID", "PostgreSQL dump table of contents exceeds 16 MiB");
+  }
+  const entries = text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith(";"));
+  if (entries.length === 0) throw new PostgresNativeDrError("PG_DUMP_TOC_INVALID", "PostgreSQL dump table of contents is empty");
+  for (const entry of entries) {
+    const match = /^\d+;\s+\d+\s+\d+\s+(.+)$/u.exec(entry);
+    if (!match) throw new PostgresNativeDrError("PG_DUMP_TOC_INVALID", "PostgreSQL dump table of contents has an invalid record");
+    const body = match[1];
+    const descriptor = POSTGRES_TOC_DESCRIPTORS.find((candidate) => body.startsWith(`${candidate} `));
+    if (!descriptor) throw new PostgresNativeDrError("PG_DUMP_TOC_OUT_OF_SCOPE", "PostgreSQL dump contains an unsupported object kind");
+    const remainder = body.slice(descriptor.length + 1).split(/\s+/u);
+    const namespace = remainder[0] === "-" ? descriptor === "SCHEMA" ? remainder[1] : remainder[2] : remainder[0];
+    if (namespace !== "agent_bridge") {
+      throw new PostgresNativeDrError("PG_DUMP_TOC_OUT_OF_SCOPE", "PostgreSQL dump contains an object outside the agent_bridge schema");
+    }
+  }
+}
+function schemaAclRestoreList(text) {
+  validatePostgresDumpToc(text);
+  const entries = text.split(/\r?\n/u).map((line) => line.trim()).filter((line) => /^\d+;\s+\d+\s+\d+\s+ACL\s+-\s+SCHEMA\s+agent_bridge(?:\s|$)/u.test(line));
+  if (entries.length !== 1) {
+    throw new PostgresNativeDrError("PG_DUMP_TOC_INVALID", "PostgreSQL dump must contain exactly one Agent Bridge schema ACL entry");
+  }
+  return `${entries[0]}
+`;
+}
+function parsePostgresToolMajor(output) {
+  const match = /\(PostgreSQL\)\s+(\d+)(?:\.\d+)?(?:\s|$)/u.exec(output.trim());
+  if (!match) throw new Error("cannot parse PostgreSQL tool version");
+  const major = Number(match[1]);
+  if (!Number.isSafeInteger(major) || major < 15 || major > 18) {
+    throw new Error(`unsupported PostgreSQL tool version: ${match[1]}`);
+  }
+  return major;
+}
+function validateRole(value, index) {
+  assertRecord(value, `roles[${index}]`);
+  exactKeys(value, ["name", "kind"], `roles[${index}]`);
+  if (typeof value.name !== "string" || !validPostgresIdentifier(value.name)) throw new Error(`roles[${index}].name is invalid`);
+  if (!["derived", "schema-owner", "object-role", "external-principal"].includes(value.kind)) {
+    throw new Error(`roles[${index}].kind is invalid`);
+  }
+  if (value.kind === "derived" && !DERIVED_ROLE.test(value.name)) {
+    throw new Error(`roles[${index}] is not an Agent Bridge derived role`);
+  }
+  if (value.kind !== "derived" && value.kind !== "schema-owner" && DERIVED_ROLE.test(value.name)) {
+    throw new Error(`roles[${index}] must classify its Agent Bridge derived role`);
+  }
+  return { name: value.name, kind: value.kind };
+}
+function validateMembership(value, index) {
+  assertRecord(value, `memberships[${index}]`);
+  exactKeys(value, ["role", "member", "adminOption", "inheritOption", "setOption"], `memberships[${index}]`);
+  if (typeof value.role !== "string" || typeof value.member !== "string") {
+    throw new Error(`memberships[${index}] role and member must be strings`);
+  }
+  for (const field of ["adminOption", "inheritOption", "setOption"]) {
+    if (typeof value[field] !== "boolean") throw new Error(`memberships[${index}].${field} must be boolean`);
+  }
+  const adminOption = value.adminOption;
+  const inheritOption = value.inheritOption;
+  const setOption = value.setOption;
+  return {
+    role: value.role,
+    member: value.member,
+    adminOption,
+    inheritOption,
+    setOption
+  };
+}
+var DEFAULT_PRIVILEGE_TYPES = /* @__PURE__ */ new Set([
+  "CREATE",
+  "DELETE",
+  "EXECUTE",
+  "INSERT",
+  "MAINTAIN",
+  "REFERENCES",
+  "SELECT",
+  "TRIGGER",
+  "TRUNCATE",
+  "UPDATE",
+  "USAGE"
+]);
+var DEFAULT_PRIVILEGES_BY_OBJECT = {
+  r: /* @__PURE__ */ new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", "MAINTAIN"]),
+  S: /* @__PURE__ */ new Set(["USAGE", "SELECT", "UPDATE"]),
+  f: /* @__PURE__ */ new Set(["EXECUTE"]),
+  T: /* @__PURE__ */ new Set(["USAGE"]),
+  n: /* @__PURE__ */ new Set(["USAGE", "CREATE"])
+};
+function validateDefaultAclGrant(value, aclIndex, grantIndex) {
+  const label = `defaultAcls[${aclIndex}].grants[${grantIndex}]`;
+  assertRecord(value, label);
+  if (value.granteeKind === "public") {
+    exactKeys(value, ["grantor", "granteeKind", "privilege", "grantable"], label);
+  } else if (value.granteeKind === "role") {
+    exactKeys(value, ["grantor", "granteeKind", "grantee", "privilege", "grantable"], label);
+    if (typeof value.grantee !== "string" || !validPostgresIdentifier(value.grantee)) {
+      throw new Error(`${label}.grantee is invalid`);
+    }
+  } else {
+    throw new Error(`${label}.granteeKind is invalid`);
+  }
+  if (typeof value.grantor !== "string" || !validPostgresIdentifier(value.grantor)) throw new Error(`${label}.grantor is invalid`);
+  if (typeof value.privilege !== "string" || !DEFAULT_PRIVILEGE_TYPES.has(value.privilege)) {
+    throw new Error(`${label}.privilege is invalid`);
+  }
+  if (typeof value.grantable !== "boolean") throw new Error(`${label}.grantable must be boolean`);
+  return value;
+}
+function validateDefaultAcl(value, index) {
+  assertRecord(value, `defaultAcls[${index}]`);
+  exactKeys(value, ["owner", "schema", "objectType", "grants"], `defaultAcls[${index}]`);
+  if (typeof value.owner !== "string" || !validPostgresIdentifier(value.owner)) {
+    throw new Error(`defaultAcls[${index}].owner is invalid`);
+  }
+  if (value.schema !== null && value.schema !== "agent_bridge") {
+    throw new Error(`defaultAcls[${index}] references a schema outside Agent Bridge`);
+  }
+  if (!(value.objectType === "r" || value.objectType === "S" || value.objectType === "f" || value.objectType === "T" || value.objectType === "n")) {
+    throw new Error(`defaultAcls[${index}].objectType is invalid`);
+  }
+  if (value.objectType === "n" && value.schema !== null) {
+    throw new Error(`defaultAcls[${index}] cannot scope schema privileges to a schema`);
+  }
+  if (!Array.isArray(value.grants)) throw new Error(`defaultAcls[${index}].grants must be an array`);
+  const grants = value.grants.map((grant, grantIndex) => validateDefaultAclGrant(grant, index, grantIndex));
+  if (grants.some((grant) => !DEFAULT_PRIVILEGES_BY_OBJECT[value.objectType].has(grant.privilege))) {
+    throw new Error(`defaultAcls[${index}] contains a privilege invalid for its object type`);
+  }
+  return {
+    owner: value.owner,
+    schema: value.schema,
+    objectType: value.objectType,
+    grants
+  };
+}
+function validatePostgresRoleInventory(value) {
+  assertRecord(value, "PostgreSQL role inventory");
+  exactKeys(value, ["schema", "version", "databaseName", "roles", "memberships", "defaultAcls"], "PostgreSQL role inventory");
+  if (value.schema !== POSTGRES_NATIVE_DR_ROLE_SCHEMA || value.version !== POSTGRES_NATIVE_DR_ROLE_VERSION) {
+    throw new Error("PostgreSQL role inventory schema or version is unsupported");
+  }
+  if (typeof value.databaseName !== "string" || !validPostgresIdentifier(value.databaseName)) {
+    throw new Error("PostgreSQL role inventory databaseName is invalid");
+  }
+  if (!Array.isArray(value.roles) || !Array.isArray(value.memberships) || !Array.isArray(value.defaultAcls)) {
+    throw new Error("PostgreSQL role inventory roles, memberships, and defaultAcls must be arrays");
+  }
+  const roles = value.roles.map(validateRole);
+  const expectedDerivedSuffix = createHash2("md5").update(value.databaseName).digest("hex").slice(0, 16);
+  if (roles.some((role) => DERIVED_ROLE.test(role.name) && !role.name.endsWith(`_${expectedDerivedSuffix}`))) {
+    throw new Error("PostgreSQL role inventory contains a derived role for another database");
+  }
+  if (roles.filter((role) => role.kind === "schema-owner").length !== 1) {
+    throw new Error("PostgreSQL role inventory must contain exactly one schema owner");
+  }
+  const roleNames = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (roleNames.has(role.name)) throw new Error(`duplicate PostgreSQL role: ${role.name}`);
+    roleNames.add(role.name);
+  }
+  const memberships = value.memberships.map(validateMembership);
+  const membershipKeys = /* @__PURE__ */ new Set();
+  for (const membership of memberships) {
+    if (!roleNames.has(membership.role) || !roleNames.has(membership.member)) {
+      throw new Error("PostgreSQL role membership references a role outside the inventory");
+    }
+    if (membership.role === membership.member) throw new Error("PostgreSQL role membership cannot be self-referential");
+    const key = `${membership.role}\0${membership.member}`;
+    if (membershipKeys.has(key)) throw new Error("duplicate PostgreSQL role membership");
+    membershipKeys.add(key);
+  }
+  const defaultAcls = value.defaultAcls.map(validateDefaultAcl);
+  const defaultAclKeys = /* @__PURE__ */ new Set();
+  for (const acl of defaultAcls) {
+    if (!roleNames.has(acl.owner)) throw new Error("PostgreSQL default ACL owner is outside the inventory");
+    const aclKey = [acl.owner, acl.schema ?? "", acl.objectType].join("\0");
+    if (defaultAclKeys.has(aclKey)) throw new Error("duplicate PostgreSQL default ACL");
+    defaultAclKeys.add(aclKey);
+    const grantKeys = /* @__PURE__ */ new Set();
+    for (const grant of acl.grants) {
+      if (grant.grantor !== acl.owner) {
+        throw new Error("PostgreSQL default ACL with a grantor distinct from its owner is unsupported");
+      }
+      if (grant.granteeKind === "role" && !roleNames.has(grant.grantee)) {
+        throw new Error("PostgreSQL default ACL references a grantee outside the inventory");
+      }
+      const grantKey = [
+        grant.grantor,
+        grant.granteeKind,
+        grant.granteeKind === "role" ? grant.grantee : "",
+        grant.privilege,
+        String(grant.grantable)
+      ].join("\0");
+      if (grantKeys.has(grantKey)) throw new Error("duplicate PostgreSQL default ACL grant");
+      grantKeys.add(grantKey);
+    }
+  }
+  return {
+    schema: POSTGRES_NATIVE_DR_ROLE_SCHEMA,
+    version: POSTGRES_NATIVE_DR_ROLE_VERSION,
+    databaseName: value.databaseName,
+    roles: roles.sort((left, right) => left.name.localeCompare(right.name)),
+    memberships: memberships.sort((left, right) => left.role.localeCompare(right.role) || left.member.localeCompare(right.member)),
+    defaultAcls: defaultAcls.map((acl) => ({
+      ...acl,
+      grants: acl.grants.sort((left, right) => left.grantor.localeCompare(right.grantor) || left.granteeKind.localeCompare(right.granteeKind) || (left.granteeKind === "role" ? left.grantee : "").localeCompare(
+        right.granteeKind === "role" ? right.grantee : ""
+      ) || left.privilege.localeCompare(right.privilege) || Number(left.grantable) - Number(right.grantable))
+    })).sort((left, right) => left.owner.localeCompare(right.owner) || (left.schema ?? "").localeCompare(right.schema ?? "") || left.objectType.localeCompare(right.objectType))
+  };
+}
+function canonicalPostgresRoleInventory(inventory) {
+  return `${JSON.stringify(validatePostgresRoleInventory(inventory))}
+`;
+}
+function quoteIdentifier(value) {
+  if (!validPostgresIdentifier(value)) throw new Error("PostgreSQL role name is invalid");
+  return `"${value.split('"').join('""')}"`;
+}
+function buildPostgresRoleShellStatements(inventory) {
+  return validatePostgresRoleInventory(inventory).roles.map((role) => `CREATE ROLE ${quoteIdentifier(role.name)} NOLOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOREPLICATION NOBYPASSRLS INHERIT;`);
+}
+function buildPostgresMembershipStatements(inventory, serverMajor2) {
+  if (!Number.isSafeInteger(serverMajor2) || serverMajor2 < 15 || serverMajor2 > 18) {
+    throw new Error("PostgreSQL membership target major must be between 15 and 18");
+  }
+  return validatePostgresRoleInventory(inventory).memberships.map((membership) => {
+    if (serverMajor2 === 15) {
+      if (!membership.inheritOption || !membership.setOption) {
+        throw new Error("PostgreSQL 15 cannot preserve membership INHERIT FALSE or SET FALSE semantics");
+      }
+      return `GRANT ${quoteIdentifier(membership.role)} TO ${quoteIdentifier(membership.member)}${membership.adminOption ? " WITH ADMIN OPTION" : ""};`;
+    }
+    const options = [
+      `ADMIN ${membership.adminOption ? "OPTION" : "FALSE"}`,
+      `INHERIT ${membership.inheritOption ? "TRUE" : "FALSE"}`,
+      `SET ${membership.setOption ? "TRUE" : "FALSE"}`
+    ].join(", ");
+    return `GRANT ${quoteIdentifier(membership.role)} TO ${quoteIdentifier(membership.member)} WITH ${options};`;
+  });
+}
+var DEFAULT_PRIVILEGE_OBJECTS = {
+  r: "TABLES",
+  S: "SEQUENCES",
+  f: "FUNCTIONS",
+  T: "TYPES",
+  n: "SCHEMAS"
+};
+function buildPostgresDefaultPrivilegeStatements(inventory) {
+  return validatePostgresRoleInventory(inventory).defaultAcls.map((acl) => {
+    const prefix = `ALTER DEFAULT PRIVILEGES FOR ROLE ${quoteIdentifier(acl.owner)}${acl.schema ? ` IN SCHEMA ${quoteIdentifier(acl.schema)}` : ""}`;
+    const objects = DEFAULT_PRIVILEGE_OBJECTS[acl.objectType];
+    const statements = [
+      `SET LOCAL ROLE ${quoteIdentifier(acl.owner)}`,
+      `${prefix} REVOKE ALL PRIVILEGES ON ${objects} FROM PUBLIC`,
+      `${prefix} REVOKE ALL PRIVILEGES ON ${objects} FROM ${quoteIdentifier(acl.owner)}`
+    ];
+    for (const grant of acl.grants) {
+      const grantee = grant.granteeKind === "public" ? "PUBLIC" : quoteIdentifier(grant.grantee);
+      statements.push(`${prefix} GRANT ${grant.privilege} ON ${objects} TO ${grantee}${grant.grantable ? " WITH GRANT OPTION" : ""}`);
+    }
+    statements.push("RESET ROLE");
+    return `${statements.join("; ")};`;
+  });
+}
+function resolvePostgresTool(tool, toolDirectory) {
+  const executable = process.platform === "win32" ? `${tool}.exe` : tool;
+  const candidates = toolDirectory ? [resolve2(toolDirectory, executable)] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => resolve2(directory, executable));
+  for (const candidate of candidates) {
+    try {
+      accessSync(candidate, constants2.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  throw new PostgresNativeDrError("POSTGRES_TOOL_NOT_FOUND", `${tool} was not found in the selected PostgreSQL tool directory`);
+}
+async function runPostgresTool(command, args, environment, inputFileDescriptor) {
+  return await new Promise((resolveResult, reject) => {
+    const child = spawn(command, args, {
+      env: environment,
+      shell: false,
+      windowsHide: true,
+      stdio: [inputFileDescriptor ?? "ignore", "pipe", "pipe"]
+    });
+    const stdout = createBoundedToolOutput(POSTGRES_TOC_MAX_BYTES);
+    const stderr = createBoundedToolOutput(POSTGRES_TOC_MAX_BYTES);
+    let timedOut = false;
+    let forceKill;
+    const deadline = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      forceKill = setTimeout(() => child.kill("SIGKILL"), 5e3);
+      forceKill.unref();
+    }, 30 * 6e4);
+    deadline.unref();
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.once("error", (error) => {
+      clearTimeout(deadline);
+      if (forceKill) clearTimeout(forceKill);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(deadline);
+      if (forceKill) clearTimeout(forceKill);
+      const capturedStdout = stdout.read();
+      const capturedStderr = stderr.read();
+      resolveResult({
+        stdout: capturedStdout.bytes.toString("utf8"),
+        stderr: capturedStderr.bytes.toString("utf8"),
+        exitCode: code ?? -1,
+        timedOut,
+        stdoutTruncated: capturedStdout.truncated,
+        stderrTruncated: capturedStderr.truncated
+      });
+    });
+  });
+}
+var defaultDependencies = {
+  createClient: (connectionUrl) => {
+    const client = new pg.Client({
+      connectionString: connectionUrl,
+      application_name: "agent-bridge-native-dr",
+      connectionTimeoutMillis: 1e4,
+      query_timeout: 6e4
+    });
+    client.on("error", () => {
+    });
+    return client;
+  },
+  resolveTool: resolvePostgresTool,
+  runTool: runPostgresTool,
+  now: () => /* @__PURE__ */ new Date(),
+  randomId: () => randomUUID(),
+  checkRowIsolationReady: (client) => rowIsolationReady(
+    client,
+    true
+  ),
+  removePath: (path) => rmSync(path, { recursive: true, force: true })
+};
+function dependencies(overrides) {
+  return { ...defaultDependencies, ...overrides };
+}
+function requiredEnvironmentUrl(environment, name) {
+  const value = environment[name]?.trim();
+  if (!value) throw new PostgresNativeDrError("MISSING_DATABASE_AUTHORITY", `${name} is required`);
+  return value;
+}
+function validateBackupId(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(normalized)) {
+    throw new PostgresNativeDrError("INVALID_BACKUP_ID", "PostgreSQL native DR backup ID must be a UUID");
+  }
+  return normalized;
+}
+function sanitizedUnexpectedError(error, authorityUrl) {
+  const message = error instanceof Error ? error.message : "unknown error";
+  let password = "";
+  try {
+    password = decodeURIComponent(new URL(authorityUrl).password);
+  } catch {
+  }
+  return [authorityUrl, password].filter(Boolean).reduce(
+    (text, secret) => text.split(secret).join("[redacted]"),
+    message
+  ).slice(0, 512);
+}
+function serverMajor(serverVersionNum) {
+  if (!Number.isSafeInteger(serverVersionNum)) throw new PostgresNativeDrError("INVALID_SERVER_VERSION", "PostgreSQL server version is invalid");
+  const major = Math.floor(serverVersionNum / 1e4);
+  if (major < 15 || major > 18) throw new PostgresNativeDrError("UNSUPPORTED_SERVER_VERSION", "PostgreSQL server major must be between 15 and 18");
+  return major;
+}
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function validateArtifactAnchor(value, label) {
+  assertRecord(value, label);
+  exactKeys(value, [
+    "descriptor",
+    "device",
+    "inode",
+    "size",
+    "ctimeNanoseconds",
+    "mtimeNanoseconds",
+    "sha256"
+  ], label);
+  if (!Number.isSafeInteger(value.descriptor) || value.descriptor < 0 || typeof value.device !== "string" || !/^[0-9]+$/u.test(value.device) || typeof value.inode !== "string" || !/^[0-9]+$/u.test(value.inode) || typeof value.size !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(value.size) || typeof value.ctimeNanoseconds !== "string" || !/^[0-9]+$/u.test(value.ctimeNanoseconds) || typeof value.mtimeNanoseconds !== "string" || !/^[0-9]+$/u.test(value.mtimeNanoseconds) || typeof value.sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(value.sha256)) {
+    throw new PostgresNativeDrError("ARTIFACT_ANCHOR_INVALID", `${label} is invalid`);
+  }
+  return value;
+}
+function artifactStat(descriptor) {
+  try {
+    const stat = fstatSync2(descriptor, { bigint: true });
+    if (!stat.isFile()) throw new Error("not a regular file");
+    return stat;
+  } catch {
+    throw new PostgresNativeDrError("ARTIFACT_ANCHOR_INVALID", "PostgreSQL native DR artifact anchor is not an open regular file");
+  }
+}
+function sameArtifact(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+function statMatchesAnchor(stat, anchor) {
+  return stat.dev.toString() === anchor.device && stat.ino.toString() === anchor.inode && stat.size.toString() === anchor.size && stat.ctimeNs.toString() === anchor.ctimeNanoseconds && stat.mtimeNs.toString() === anchor.mtimeNanoseconds;
+}
+function openAnchoredArtifact(inputPath, anchorInput) {
+  const anchor = validateArtifactAnchor(anchorInput, "PostgreSQL artifact anchor");
+  const anchorFileStat = artifactStat(anchor.descriptor);
+  if (!statMatchesAnchor(anchorFileStat, anchor)) {
+    throw new PostgresNativeDrError("ARTIFACT_IDENTITY_MISMATCH", "PostgreSQL native DR retained anchor changed after bundle verification");
+  }
+  const path = resolve2(inputPath);
+  verifyPrivatePathAccess(path, "file");
+  const pathStat = lstatSync2(path, { bigint: true });
+  if (!pathStat.isFile() || pathStat.isSymbolicLink()) {
+    throw new PostgresNativeDrError("ARTIFACT_TYPE_INVALID", "PostgreSQL native DR artifact must be a regular file");
+  }
+  const noFollow = "O_NOFOLLOW" in constants2 ? constants2.O_NOFOLLOW : 0;
+  const descriptor = openSync2(path, constants2.O_RDONLY | noFollow);
+  const opened = fstatSync2(descriptor, { bigint: true });
+  if (!opened.isFile() || opened.dev !== pathStat.dev || opened.ino !== pathStat.ino || !sameArtifact(opened, anchorFileStat)) {
+    closeSync2(descriptor);
+    throw new PostgresNativeDrError("ARTIFACT_IDENTITY_MISMATCH", "PostgreSQL native DR artifact path does not match its retained anchor");
+  }
+  return { descriptor, anchorStat: anchorFileStat };
+}
+function assertAnchoredDescriptorUnchanged(descriptor, anchorStat) {
+  if (!sameArtifact(artifactStat(descriptor), anchorStat)) {
+    throw new PostgresNativeDrError("ARTIFACT_IDENTITY_MISMATCH", "PostgreSQL native DR artifact changed while it was in use");
+  }
+}
+function readAnchoredArtifact(path, anchor, maximumBytes) {
+  const opened = openAnchoredArtifact(path, anchor);
+  try {
+    if (opened.anchorStat.size > BigInt(maximumBytes)) {
+      throw new PostgresNativeDrError("ROLE_INVENTORY_TOO_LARGE", "PostgreSQL role inventory exceeds 1 MiB");
+    }
+    const content = Buffer.alloc(Number(opened.anchorStat.size));
+    let offset = 0;
+    while (offset < content.length) {
+      const count = readSync2(opened.descriptor, content, offset, content.length - offset, null);
+      if (count === 0) break;
+      offset += count;
+    }
+    if (offset !== content.length) throw new PostgresNativeDrError("ARTIFACT_IDENTITY_MISMATCH", "PostgreSQL native DR artifact changed while it was read");
+    assertAnchoredDescriptorUnchanged(opened.descriptor, opened.anchorStat);
+    return content;
+  } finally {
+    closeSync2(opened.descriptor);
+  }
+}
+async function runToolWithAnchoredInput(path, anchor, run) {
+  const opened = openAnchoredArtifact(path, anchor);
+  try {
+    const result = await run(opened.descriptor);
+    assertAnchoredDescriptorUnchanged(opened.descriptor, opened.anchorStat);
+    return result;
+  } finally {
+    closeSync2(opened.descriptor);
+  }
+}
+function validateArtifactAnchors(value) {
+  assertRecord(value, "PostgreSQL artifact anchors");
+  exactKeys(value, ["dump", "roles"], "PostgreSQL artifact anchors");
+  return {
+    dump: validateArtifactAnchor(value.dump, "PostgreSQL dump anchor"),
+    roles: validateArtifactAnchor(value.roles, "PostgreSQL roles anchor")
+  };
+}
+function quoteSqlIdentifier(value) {
+  if (!value || /[\u0000-\u001f\u007f]/u.test(value)) throw new Error("PostgreSQL identifier is invalid");
+  return `"${value.split('"').join('""')}"`;
+}
+function assertToolSucceeded(result, code, tool) {
+  if (result.timedOut) throw new PostgresNativeDrError(`${code}_TIMEOUT`, `${tool} exceeded the 30 minute execution deadline and was terminated`);
+  if (result.exitCode !== 0) {
+    const diagnostic = result.stderr.trim().replace(/postgres(?:ql)?:\/\/\S+/giu, "[redacted PostgreSQL URL]").replace(/password\s*=\s*\S+/giu, "password=[redacted]").slice(0, 8192);
+    throw new PostgresNativeDrError(
+      code,
+      `${tool} failed with exit code ${result.exitCode}${diagnostic ? `: ${diagnostic}` : ""}`
+    );
+  }
+}
+function assertPostgresTocOutputComplete(result) {
+  if (result.stdoutTruncated) {
+    throw new PostgresNativeDrError(
+      "PG_DUMP_TOC_TRUNCATED",
+      "PostgreSQL dump table of contents exceeds the 16 MiB verification limit"
+    );
+  }
+}
+async function checkedTools(sourceMajor, libpqEnvironment, toolDirectory, deps) {
+  const pgDump = deps.resolveTool("pg_dump", toolDirectory);
+  const pgRestore = deps.resolveTool("pg_restore", toolDirectory);
+  const dumpVersion = await deps.runTool(pgDump, ["--version"], libpqEnvironment);
+  const restoreVersion = await deps.runTool(pgRestore, ["--version"], libpqEnvironment);
+  assertToolSucceeded(dumpVersion, "PG_DUMP_VERSION_FAILED", "pg_dump --version");
+  assertToolSucceeded(restoreVersion, "PG_RESTORE_VERSION_FAILED", "pg_restore --version");
+  if (parsePostgresToolMajor(dumpVersion.stdout) !== sourceMajor || parsePostgresToolMajor(restoreVersion.stdout) !== sourceMajor) {
+    throw new PostgresNativeDrError("POSTGRES_TOOL_MAJOR_MISMATCH", "pg_dump and pg_restore must exactly match the database server major");
+  }
+  return { pgDump, pgRestore, pgDumpVersion: dumpVersion.stdout.trim() };
+}
+async function collectPostgresRoleInventory(client, databaseName) {
+  const roleRows = await client.query(`
+    WITH derived_names(name) AS (
+      SELECT prefix||substr(pg_catalog.md5(pg_catalog.current_database()),1,16)
+      FROM unnest(ARRAY[
+        'agent_bridge_runtime_','agent_bridge_data_owner_','agent_bridge_context_reader_',
+        'agent_bridge_event_writer_','agent_bridge_control_owner_','agent_bridge_control_operator_',
+        'agent_bridge_control_auditor_','agent_bridge_archive_operator_'
+      ]) prefix
+    ), object_roles AS (
+      SELECT namespace.nspowner AS oid, 'schema-owner'::text AS kind
+      FROM pg_catalog.pg_namespace namespace WHERE namespace.nspname='agent_bridge'
+      UNION SELECT class.relowner, 'object-role' FROM pg_catalog.pg_class class
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=class.relnamespace
+        WHERE namespace.nspname='agent_bridge'
+      UNION SELECT procedure.proowner, 'object-role' FROM pg_catalog.pg_proc procedure
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=procedure.pronamespace
+        WHERE namespace.nspname='agent_bridge'
+      UNION SELECT type.typowner, 'object-role' FROM pg_catalog.pg_type type
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=type.typnamespace
+        WHERE namespace.nspname='agent_bridge'
+      UNION SELECT acl.grantor, 'object-role' FROM pg_catalog.pg_namespace namespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(namespace.nspacl) acl WHERE namespace.nspname='agent_bridge'
+      UNION SELECT acl.grantee, 'object-role' FROM pg_catalog.pg_namespace namespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(namespace.nspacl) acl WHERE namespace.nspname='agent_bridge' AND acl.grantee<>0
+      UNION SELECT acl.grantor, 'object-role' FROM pg_catalog.pg_class class
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=class.relnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(class.relacl) acl WHERE namespace.nspname='agent_bridge'
+      UNION SELECT acl.grantee, 'object-role' FROM pg_catalog.pg_class class
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=class.relnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(class.relacl) acl WHERE namespace.nspname='agent_bridge' AND acl.grantee<>0
+      UNION SELECT acl.grantor, 'object-role' FROM pg_catalog.pg_proc procedure
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=procedure.pronamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(procedure.proacl) acl WHERE namespace.nspname='agent_bridge'
+      UNION SELECT acl.grantee, 'object-role' FROM pg_catalog.pg_proc procedure
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=procedure.pronamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(procedure.proacl) acl WHERE namespace.nspname='agent_bridge' AND acl.grantee<>0
+      UNION SELECT acl.grantor, 'object-role' FROM pg_catalog.pg_type type
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=type.typnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(type.typacl) acl WHERE namespace.nspname='agent_bridge'
+      UNION SELECT acl.grantee, 'object-role' FROM pg_catalog.pg_type type
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=type.typnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(type.typacl) acl WHERE namespace.nspname='agent_bridge' AND acl.grantee<>0
+      UNION SELECT defaults.defaclrole, 'object-role' FROM pg_catalog.pg_default_acl defaults
+        LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=defaults.defaclnamespace
+        WHERE namespace.nspname='agent_bridge' OR defaults.defaclrole=(
+          SELECT nspowner FROM pg_catalog.pg_namespace WHERE nspname='agent_bridge')
+          OR (defaults.defaclnamespace=0 AND defaults.defaclrole=(SELECT oid FROM pg_catalog.pg_roles
+            WHERE rolname='agent_bridge_control_owner_'||substr(pg_catalog.md5(pg_catalog.current_database()),1,16)))
+      UNION SELECT acl.grantor, 'object-role' FROM pg_catalog.pg_default_acl defaults
+        LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=defaults.defaclnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(defaults.defaclacl) acl WHERE namespace.nspname='agent_bridge'
+          OR defaults.defaclrole=(SELECT nspowner FROM pg_catalog.pg_namespace WHERE nspname='agent_bridge')
+          OR (defaults.defaclnamespace=0 AND defaults.defaclrole=(SELECT oid FROM pg_catalog.pg_roles
+            WHERE rolname='agent_bridge_control_owner_'||substr(pg_catalog.md5(pg_catalog.current_database()),1,16)))
+      UNION SELECT acl.grantee, 'object-role' FROM pg_catalog.pg_default_acl defaults
+        LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=defaults.defaclnamespace
+        CROSS JOIN LATERAL pg_catalog.aclexplode(defaults.defaclacl) acl WHERE acl.grantee<>0 AND (
+          namespace.nspname='agent_bridge' OR defaults.defaclrole=(
+            SELECT nspowner FROM pg_catalog.pg_namespace WHERE nspname='agent_bridge')
+          OR (defaults.defaclnamespace=0 AND defaults.defaclrole=(SELECT oid FROM pg_catalog.pg_roles
+            WHERE rolname='agent_bridge_control_owner_'||substr(pg_catalog.md5(pg_catalog.current_database()),1,16))))
+    ), base_roles AS (
+      SELECT role.oid, CASE WHEN role.rolname IN (SELECT name FROM derived_names)
+        THEN 'derived' ELSE object_roles.kind END AS kind
+      FROM pg_catalog.pg_roles role JOIN object_roles ON object_roles.oid=role.oid
+      UNION
+      SELECT role.oid, 'derived' FROM pg_catalog.pg_roles role
+      WHERE role.rolname IN (SELECT name FROM derived_names)
+    ), related_roles AS (
+      SELECT oid, kind FROM base_roles
+      UNION SELECT membership.roleid, 'external-principal' FROM pg_catalog.pg_auth_members membership
+        WHERE membership.member IN (SELECT oid FROM base_roles)
+      UNION SELECT membership.member, 'external-principal' FROM pg_catalog.pg_auth_members membership
+        WHERE membership.roleid IN (SELECT oid FROM base_roles)
+    )
+    SELECT role.rolname AS name,
+      CASE WHEN bool_or(related.kind='schema-owner') THEN 'schema-owner'
+        WHEN role.rolname IN (SELECT name FROM derived_names) THEN 'derived'
+        WHEN bool_or(related.kind='object-role') THEN 'object-role'
+        ELSE 'external-principal' END AS kind
+    FROM related_roles related JOIN pg_catalog.pg_roles role ON role.oid=related.oid
+    GROUP BY role.rolname ORDER BY role.rolname`);
+  const names = roleRows.rows.map((row) => row.name);
+  const membershipRows = names.length === 0 ? { rows: [], rowCount: 0 } : await client.query(`
+    SELECT granted.rolname AS role, member.rolname AS member,
+      membership.admin_option AS "adminOption",
+      coalesce((to_jsonb(membership)->>'inherit_option')::boolean,true) AS "inheritOption",
+      coalesce((to_jsonb(membership)->>'set_option')::boolean,true) AS "setOption"
+    FROM pg_catalog.pg_auth_members membership
+    JOIN pg_catalog.pg_roles granted ON granted.oid=membership.roleid
+    JOIN pg_catalog.pg_roles member ON member.oid=membership.member
+    WHERE granted.rolname=ANY($1::text[]) AND member.rolname=ANY($1::text[])
+    ORDER BY granted.rolname,member.rolname`, [names]);
+  if (names.length > 0) {
+    const boundary = await client.query(`
+      SELECT 1 AS found FROM pg_catalog.pg_auth_members membership
+      JOIN pg_catalog.pg_roles granted ON granted.oid=membership.roleid
+      JOIN pg_catalog.pg_roles member ON member.oid=membership.member
+      WHERE (granted.rolname=ANY($1::text[])) <> (member.rolname=ANY($1::text[]))
+      LIMIT 1`, [names]);
+    if (boundary.rows.length > 0) {
+      throw new PostgresNativeDrError(
+        "TRANSITIVE_ROLE_MEMBERSHIP_UNSUPPORTED",
+        "PostgreSQL role inventory has a transitive external membership outside the bounded restore graph"
+      );
+    }
+  }
+  const defaultPrivilegeRows = await client.query(`
+    SELECT owner.rolname AS owner,
+      namespace.nspname AS schema,
+      defaults.defaclobjtype::text AS "objectType",
+      grantor.rolname AS grantor,
+      CASE WHEN acl.grantee IS NULL THEN NULL ELSE acl.grantee=0 END AS "granteePublic",
+      grantee.rolname AS grantee,
+      acl.privilege_type AS privilege,
+      acl.is_grantable AS grantable
+    FROM pg_catalog.pg_default_acl defaults
+    JOIN pg_catalog.pg_roles owner ON owner.oid=defaults.defaclrole
+    LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.oid=defaults.defaclnamespace
+    LEFT JOIN LATERAL pg_catalog.aclexplode(defaults.defaclacl) acl ON true
+    LEFT JOIN pg_catalog.pg_roles grantor ON grantor.oid=acl.grantor
+    LEFT JOIN pg_catalog.pg_roles grantee ON grantee.oid=acl.grantee
+    WHERE namespace.nspname='agent_bridge' OR defaults.defaclrole=(
+      SELECT nspowner FROM pg_catalog.pg_namespace WHERE nspname='agent_bridge')
+      OR (defaults.defaclnamespace=0 AND defaults.defaclrole=(SELECT oid FROM pg_catalog.pg_roles
+        WHERE rolname='agent_bridge_control_owner_'||substr(pg_catalog.md5(pg_catalog.current_database()),1,16)))
+    ORDER BY owner.rolname,namespace.nspname NULLS FIRST,defaults.defaclobjtype,
+      grantor.rolname,grantee,acl.privilege_type,acl.is_grantable`);
+  const defaultAcls = [];
+  for (const row of defaultPrivilegeRows.rows) {
+    let acl = defaultAcls.find((candidate) => candidate.owner === row.owner && candidate.schema === row.schema && candidate.objectType === row.objectType);
+    if (!acl) {
+      acl = { owner: row.owner, schema: row.schema, objectType: row.objectType, grants: [] };
+      defaultAcls.push(acl);
+    }
+    if (row.grantor !== null || row.granteePublic !== null || row.grantee !== null || row.privilege !== null || row.grantable !== null) {
+      if (row.grantor === null || row.granteePublic === null || row.privilege === null || row.grantable === null || !row.granteePublic && row.grantee === null) {
+        throw new PostgresNativeDrError("DEFAULT_ACL_INVALID", "PostgreSQL default ACL has an incomplete privilege record");
+      }
+      acl.grants.push({
+        grantor: row.grantor,
+        ...row.granteePublic ? { granteeKind: "public" } : { granteeKind: "role", grantee: row.grantee },
+        privilege: row.privilege,
+        grantable: row.grantable
+      });
+    }
+  }
+  return validatePostgresRoleInventory({
+    schema: POSTGRES_NATIVE_DR_ROLE_SCHEMA,
+    version: POSTGRES_NATIVE_DR_ROLE_VERSION,
+    databaseName,
+    roles: roleRows.rows,
+    memberships: membershipRows.rows,
+    defaultAcls
+  });
+}
+async function collectSnapshotMetadata(client, checkRowReady) {
+  const metadata = await client.query(
+    `SELECT current_database() AS "databaseName", current_setting('server_version_num') AS "serverVersionNum"`
+  );
+  const databaseName = metadata.rows[0]?.databaseName;
+  const serverVersionNum = Number(metadata.rows[0]?.serverVersionNum);
+  if (!databaseName) throw new PostgresNativeDrError("SOURCE_METADATA_INVALID", "source database metadata is unavailable");
+  serverMajor(serverVersionNum);
+  const migrationRows = await client.query(
+    `SELECT version,name,checksum FROM agent_bridge.schema_migrations ORDER BY version`
+  );
+  const migrations = migrationRows.rows.map((row) => ({
+    version: Number(row.version),
+    name: row.name,
+    checksum: row.checksum
+  }));
+  for (const migration of migrations) {
+    if (!Number.isSafeInteger(migration.version) || migration.version < 1 || !/^[a-z0-9_]+$/u.test(migration.name) || !/^[0-9a-f]{64}$/u.test(migration.checksum)) {
+      throw new PostgresNativeDrError("SOURCE_MIGRATION_INVALID", "source migration inventory is invalid");
+    }
+  }
+  if (migrations.length === 0) throw new PostgresNativeDrError("SOURCE_SCHEMA_EMPTY", "source has no Agent Bridge migrations");
+  const tableRows = await client.query(`
+    SELECT table_name AS "tableName" FROM information_schema.tables
+    WHERE table_schema='agent_bridge' AND table_type='BASE TABLE' ORDER BY table_name`);
+  const tableCounts = {};
+  for (const row of tableRows.rows) {
+    const qualified = `agent_bridge.${row.tableName}`;
+    const count = await client.query(
+      `SELECT count(*)::text AS count FROM agent_bridge.${quoteSqlIdentifier(row.tableName)}`
+    );
+    const value = count.rows[0]?.count;
+    if (!value || !/^(?:0|[1-9][0-9]*)$/u.test(value)) throw new PostgresNativeDrError("SOURCE_COUNT_INVALID", `source count is invalid for ${qualified}`);
+    tableCounts[qualified] = value;
+  }
+  const claimed = await client.query(
+    `SELECT count(*)::text AS count FROM agent_bridge.deliveries WHERE state='claimed'`
+  );
+  const claimedDeliveryCount = claimed.rows[0]?.count;
+  if (!claimedDeliveryCount || !/^(?:0|[1-9][0-9]*)$/u.test(claimedDeliveryCount)) {
+    throw new PostgresNativeDrError("SOURCE_COUNT_INVALID", "source claimed delivery count is invalid");
+  }
+  const readiness = await client.query(`
+    SELECT agent_bridge.security_schema_ready() AS security,
+      agent_bridge.owner_control_plane_ready() AS "ownerControl",
+      agent_bridge.portable_archive_ready() AS "portableArchive",
+      agent_bridge.credential_security_prerequisite_definition() AS "securityDefinition",
+      agent_bridge.row_isolation_catalog_definition() AS "rowIsolationDefinition",
+      agent_bridge.owner_control_attestation_definition() AS "ownerControlDefinition",
+      agent_bridge.portable_archive_attestation_definition() AS "portableArchiveDefinition"`);
+  const ready = readiness.rows[0];
+  const rowReady = await checkRowReady(client);
+  if (!ready?.security || !rowReady || !ready.ownerControl || !ready.portableArchive || typeof ready.securityDefinition !== "string" || typeof ready.rowIsolationDefinition !== "string" || typeof ready.ownerControlDefinition !== "string" || typeof ready.portableArchiveDefinition !== "string") {
+    throw new PostgresNativeDrError("SOURCE_NOT_READY", "source PostgreSQL schema failed readiness attestation");
+  }
+  return {
+    databaseName,
+    serverVersionNum,
+    migrations,
+    tableCounts,
+    claimedDeliveryCount,
+    readinessAttestations: {
+      securitySchemaSha256: sha256(ready.securityDefinition),
+      rowIsolationSha256: sha256(ready.rowIsolationDefinition),
+      ownerControlSha256: sha256(ready.ownerControlDefinition),
+      portableArchiveSha256: sha256(ready.portableArchiveDefinition)
+    }
+  };
+}
+function createPrivateEmptyFile(path) {
+  const descriptor = openSync2(path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL, 384);
+  closeSync2(descriptor);
+  securePrivatePath(path, "file");
+  verifyPrivatePathAccess(path, "file");
+}
+async function backupPostgresNativeDr(options) {
+  const env = options.environment ?? process.env;
+  const sourceUrl = requiredEnvironmentUrl(env, "AGENT_BRIDGE_DR_SOURCE_DATABASE_URL");
+  const stage = resolve2(options.stagingDirectory);
+  verifyPrivatePathAccess(stage, "directory");
+  const deps = dependencies(options.dependencies);
+  const libpqDirectory = mkdtempSync(join(stage, ".postgres-dr-libpq-"));
+  securePrivatePath(libpqDirectory, "directory");
+  verifyPrivatePathAccess(libpqDirectory, "directory");
+  const dumpPath = join(stage, "postgres-database.dump");
+  const rolesPath = join(stage, "postgres-roles.json");
+  let source;
+  let postInventoryClient;
+  let lockHeld = false;
+  let transactionOpen = false;
+  let primaryFailure;
+  let backupCompleted = false;
+  try {
+    const libpq = createPostgresDrLibpqFiles(sourceUrl, libpqDirectory);
+    createPrivateEmptyFile(dumpPath);
+    source = deps.createClient(sourceUrl);
+    await source.connect();
+    await source.query("SELECT pg_catalog.pg_advisory_lock($1)", [NATIVE_DR_ADVISORY_LOCK_KEY]);
+    lockHeld = true;
+    await source.query("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY");
+    transactionOpen = true;
+    const snapshotResult = await source.query("SELECT pg_catalog.pg_export_snapshot() AS snapshot");
+    const snapshot = snapshotResult.rows[0]?.snapshot;
+    if (!snapshot) throw new PostgresNativeDrError("SNAPSHOT_EXPORT_FAILED", "PostgreSQL did not export a disaster recovery snapshot");
+    const metadata = await collectSnapshotMetadata(source, deps.checkRowIsolationReady);
+    const major = serverMajor(metadata.serverVersionNum);
+    const beforeInventory = await collectPostgresRoleInventory(source, metadata.databaseName);
+    const canonicalRoles = canonicalPostgresRoleInventory(beforeInventory);
+    const tools = await checkedTools(major, libpq.environment, options.toolDirectory, deps);
+    const dump = await deps.runTool(tools.pgDump, buildPgDumpArgs(dumpPath, snapshot, libpq.serviceName), libpq.environment);
+    assertToolSucceeded(dump, "PG_DUMP_FAILED", "pg_dump");
+    verifyPrivatePathAccess(dumpPath, "file");
+    if (statSync(dumpPath).size === 0) throw new PostgresNativeDrError("PG_DUMP_EMPTY", "pg_dump produced an empty file");
+    const listed = await deps.runTool(tools.pgRestore, buildPgRestoreListArgs(dumpPath), libpq.environment);
+    assertToolSucceeded(listed, "PG_RESTORE_LIST_FAILED", "pg_restore --list");
+    assertPostgresTocOutputComplete(listed);
+    validatePostgresDumpToc(listed.stdout);
+    schemaAclRestoreList(listed.stdout);
+    postInventoryClient = deps.createClient(sourceUrl);
+    await postInventoryClient.connect();
+    const afterInventory = await collectPostgresRoleInventory(postInventoryClient, metadata.databaseName);
+    if (canonicalPostgresRoleInventory(afterInventory) !== canonicalRoles) {
+      throw new PostgresNativeDrError("ROLE_INVENTORY_DRIFT", "PostgreSQL role inventory changed while the native DR fence was held");
+    }
+    writeFileSync(rolesPath, canonicalRoles, { encoding: "utf8", mode: 384, flag: "wx" });
+    securePrivatePath(rolesPath, "file");
+    verifyPrivatePathAccess(rolesPath, "file");
+    await source.query("COMMIT");
+    transactionOpen = false;
+    await source.query("SELECT pg_catalog.pg_advisory_unlock($1)", [NATIVE_DR_ADVISORY_LOCK_KEY]);
+    lockHeld = false;
+    const schemaVersion = Math.max(...metadata.migrations.map((migration) => migration.version));
+    const result = {
+      backupId: validateBackupId(options.backupId ?? deps.randomId()),
+      createdAt: deps.now().toISOString(),
+      kind: "postgres",
+      schema: {
+        databaseName: metadata.databaseName,
+        serverVersionNum: metadata.serverVersionNum,
+        serverMajor: major,
+        schemaVersion,
+        migrations: metadata.migrations,
+        tableCounts: metadata.tableCounts,
+        excludedDataTables: [...POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES],
+        claimedDeliveryCount: metadata.claimedDeliveryCount,
+        pgDumpVersion: tools.pgDumpVersion,
+        roleInventorySha256: sha256(canonicalRoles),
+        readinessAttestations: metadata.readinessAttestations
+      },
+      entries: [
+        { name: "postgres/database.dump", path: dumpPath },
+        { name: "postgres/roles.json", path: rolesPath }
+      ]
+    };
+    backupCompleted = true;
+    return result;
+  } catch (error) {
+    if (transactionOpen && source) await source.query("ROLLBACK").catch(() => void 0);
+    const recoveryPaths = [];
+    for (const path of [dumpPath, rolesPath]) {
+      try {
+        deps.removePath(path);
+      } catch {
+        if (existsSync(path)) recoveryPaths.push(path);
+      }
+    }
+    if (recoveryPaths.length > 0) {
+      const original = error instanceof PostgresNativeDrError ? error.code : "POSTGRES_NATIVE_BACKUP_FAILED";
+      primaryFailure = new PostgresNativeDrError(
+        "BACKUP_CLEANUP_FAILED",
+        `PostgreSQL native backup failed after ${original} and confidential staging files could not be removed`,
+        { recoveryPaths, causeCode: original }
+      );
+      throw primaryFailure;
+    }
+    if (error instanceof PostgresNativeDrError) primaryFailure = error;
+    throw error;
+  } finally {
+    if (lockHeld && source) await source.query("SELECT pg_catalog.pg_advisory_unlock($1)", [NATIVE_DR_ADVISORY_LOCK_KEY]).catch(() => void 0);
+    await postInventoryClient?.end().catch(() => void 0);
+    await source?.end().catch(() => void 0);
+    try {
+      deps.removePath(libpqDirectory);
+    } catch {
+      if (existsSync(libpqDirectory)) {
+        const recoveryPaths = [libpqDirectory, dumpPath, rolesPath].filter(existsSync);
+        throw new PostgresNativeDrError(
+          "CREDENTIAL_CLEANUP_FAILED",
+          `PostgreSQL native backup ${backupCompleted ? "completed" : "failed"}, but its credential directory could not be removed`,
+          { recoveryPaths, causeCode: primaryFailure?.code }
+        );
+      }
+    }
+  }
+}
+function validatePostgresNativeDrSchema(value) {
+  assertRecord(value, "PostgreSQL native DR schema");
+  exactKeys(value, [
+    "databaseName",
+    "serverVersionNum",
+    "serverMajor",
+    "schemaVersion",
+    "migrations",
+    "tableCounts",
+    "excludedDataTables",
+    "claimedDeliveryCount",
+    "pgDumpVersion",
+    "roleInventorySha256",
+    "readinessAttestations"
+  ], "PostgreSQL native DR schema");
+  if (typeof value.databaseName !== "string" || !ROLE_NAME.test(value.databaseName)) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL database name is invalid");
+  if (!Number.isSafeInteger(value.serverVersionNum) || serverMajor(value.serverVersionNum) !== value.serverMajor) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL server version is inconsistent");
+  if (!Number.isSafeInteger(value.schemaVersion) || value.schemaVersion < 1) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL schema version is invalid");
+  if (!Array.isArray(value.migrations) || value.migrations.length === 0) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL migrations are missing");
+  let previous = 0;
+  for (const migration of value.migrations) {
+    assertRecord(migration, "PostgreSQL migration");
+    exactKeys(migration, ["version", "name", "checksum"], "PostgreSQL migration");
+    if (!Number.isSafeInteger(migration.version) || migration.version <= previous || !/^[a-z0-9_]+$/u.test(migration.name) || !/^[0-9a-f]{64}$/u.test(migration.checksum)) {
+      throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL migration inventory is invalid");
+    }
+    previous = migration.version;
+  }
+  if (previous !== value.schemaVersion) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL schema version does not match migrations");
+  assertRecord(value.tableCounts, "PostgreSQL table counts");
+  for (const [table, count] of Object.entries(value.tableCounts)) {
+    if (!/^agent_bridge\.[a-z][a-z0-9_]*$/u.test(table) || typeof count !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(count)) {
+      throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL table count inventory is invalid");
+    }
+  }
+  for (const table of ["agent_bridge.deliveries", "agent_bridge.delivery_events", ...POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES]) {
+    if (!(table in value.tableCounts)) throw new PostgresNativeDrError("INVALID_MANIFEST", `PostgreSQL table count is missing for ${table}`);
+  }
+  if (JSON.stringify(value.excludedDataTables) !== JSON.stringify(POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES)) {
+    throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL excluded table inventory is invalid");
+  }
+  if (!/^(?:0|[1-9][0-9]*)$/u.test(value.claimedDeliveryCount)) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL claimed delivery count is invalid");
+  if (!/^[0-9a-f]{64}$/u.test(value.roleInventorySha256)) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL role inventory digest is invalid");
+  assertRecord(value.readinessAttestations, "PostgreSQL readiness attestations");
+  exactKeys(value.readinessAttestations, [
+    "securitySchemaSha256",
+    "rowIsolationSha256",
+    "ownerControlSha256",
+    "portableArchiveSha256"
+  ], "PostgreSQL readiness attestations");
+  for (const digest of Object.values(value.readinessAttestations)) {
+    if (typeof digest !== "string" || !/^[0-9a-f]{64}$/u.test(digest)) {
+      throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL readiness attestation digest is invalid");
+    }
+  }
+  if (parsePostgresToolMajor(value.pgDumpVersion) !== value.serverMajor) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL dump version does not match the source server");
+  return value;
+}
+async function verifyPostgresNativeDrArtifacts(options) {
+  const schema = validatePostgresNativeDrSchema(options.schema);
+  const anchors = validateArtifactAnchors(options.artifactAnchors);
+  const dumpPath = resolve2(options.dumpPath);
+  const rolesPath = resolve2(options.rolesPath);
+  if (anchors.roles.sha256 !== schema.roleInventorySha256) {
+    throw new PostgresNativeDrError("ROLE_INVENTORY_DIGEST_MISMATCH", "PostgreSQL role inventory digest does not match the manifest");
+  }
+  const rolesText = readAnchoredArtifact(rolesPath, anchors.roles, 1024 * 1024).toString("utf8");
+  let parsedRoles;
+  try {
+    parsedRoles = JSON.parse(rolesText);
+  } catch {
+    throw new PostgresNativeDrError("ROLE_INVENTORY_INVALID", "PostgreSQL role inventory is not valid JSON");
+  }
+  const roleInventory = validatePostgresRoleInventory(parsedRoles);
+  if (canonicalPostgresRoleInventory(roleInventory) !== rolesText) {
+    throw new PostgresNativeDrError("ROLE_INVENTORY_NOT_CANONICAL", "PostgreSQL role inventory is not in canonical form");
+  }
+  if (roleInventory.databaseName !== schema.databaseName) {
+    throw new PostgresNativeDrError("DATABASE_NAME_MISMATCH", "PostgreSQL role inventory database does not match the manifest");
+  }
+  const deps = dependencies(options.dependencies);
+  const environment = { LC_ALL: "C" };
+  const pgRestore = deps.resolveTool("pg_restore", options.toolDirectory);
+  const version = await deps.runTool(pgRestore, ["--version"], environment);
+  assertToolSucceeded(version, "PG_RESTORE_VERSION_FAILED", "pg_restore --version");
+  if (parsePostgresToolMajor(version.stdout) !== schema.serverMajor) {
+    throw new PostgresNativeDrError("POSTGRES_TOOL_MAJOR_MISMATCH", "pg_restore must exactly match the backup server major");
+  }
+  const listed = await runToolWithAnchoredInput(dumpPath, anchors.dump, (descriptor) => deps.runTool(pgRestore, buildPgRestoreListArgs(), environment, descriptor));
+  assertToolSucceeded(listed, "PG_RESTORE_LIST_FAILED", "pg_restore --list");
+  assertPostgresTocOutputComplete(listed);
+  validatePostgresDumpToc(listed.stdout);
+  schemaAclRestoreList(listed.stdout);
+  return {
+    schema,
+    roleInventory,
+    artifactAnchors: anchors,
+    dumpTocVerified: true,
+    dumpToc: listed.stdout
+  };
+}
+async function targetMetadata(client) {
+  const result = await client.query(`
+    SELECT current_database() AS "databaseName",
+      current_setting('server_version_num') AS "serverVersionNum",
+      pg_catalog.to_regnamespace('agent_bridge') IS NOT NULL AS "schemaExists",
+      NOT EXISTS (
+        SELECT 1 FROM pg_catalog.pg_namespace namespace
+        WHERE namespace.nspname NOT IN ('pg_catalog','information_schema','pg_toast','public')
+          AND namespace.nspname NOT LIKE 'pg_toast_temp_%'
+          AND namespace.nspname NOT LIKE 'pg_temp_%'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM pg_catalog.pg_class class
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=class.relnamespace
+        WHERE namespace.nspname='public'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM pg_catalog.pg_proc procedure
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=procedure.pronamespace
+        WHERE namespace.nspname='public'
+      ) AND NOT EXISTS (
+        SELECT 1 FROM pg_catalog.pg_type type
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=type.typnamespace
+        WHERE namespace.nspname='public' AND type.typtype<>'p'
+      ) AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_default_acl) AS "databaseFresh"`);
+  const row = result.rows[0];
+  if (!row) throw new PostgresNativeDrError("TARGET_METADATA_INVALID", "target database metadata is unavailable");
+  return {
+    databaseName: row.databaseName,
+    serverVersionNum: Number(row.serverVersionNum),
+    schemaExists: row.schemaExists,
+    databaseFresh: row.databaseFresh
+  };
+}
+async function targetTableCounts(client) {
+  const tableRows = await client.query(`
+    SELECT table_name AS "tableName" FROM information_schema.tables
+    WHERE table_schema='agent_bridge' AND table_type='BASE TABLE' ORDER BY table_name`);
+  const counts = {};
+  for (const row of tableRows.rows) {
+    const result = await client.query(
+      `SELECT count(*)::text AS count FROM agent_bridge.${quoteSqlIdentifier(row.tableName)}`
+    );
+    counts[`agent_bridge.${row.tableName}`] = result.rows[0]?.count ?? "";
+  }
+  return counts;
+}
+function expectedRestoredTableCounts(schema) {
+  const expected = { ...schema.tableCounts };
+  for (const table of POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES) expected[table] = "0";
+  const deliveryEvents = expected["agent_bridge.delivery_events"];
+  if (deliveryEvents === void 0) throw new PostgresNativeDrError("INVALID_MANIFEST", "PostgreSQL delivery event count is missing");
+  expected["agent_bridge.delivery_events"] = (BigInt(deliveryEvents) + BigInt(schema.claimedDeliveryCount)).toString();
+  return expected;
+}
+function compareStringMaps(actual, expected, label) {
+  const actualKeys = Object.keys(actual).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys)) throw new PostgresNativeDrError("RESTORE_COUNT_MISMATCH", `${label} table set does not match the backup`);
+  for (const key of expectedKeys) {
+    if (actual[key] !== expected[key]) throw new PostgresNativeDrError("RESTORE_COUNT_MISMATCH", `${label} count does not match for ${key}`);
+  }
+}
+function administrativeDatabaseUrl(targetUrl, targetDatabase) {
+  const url = new URL(targetUrl);
+  url.pathname = `/${targetDatabase === "postgres" ? "template1" : "postgres"}`;
+  return url.toString();
+}
+async function assertPostgresRestoreAuthority(client) {
+  const result = await client.query(`
+    SELECT role.rolsuper AS "isSuperuser"
+    FROM pg_catalog.pg_roles role
+    WHERE role.rolname=current_user`);
+  const authority = result.rows[0];
+  if (!authority?.isSuperuser) {
+    throw new PostgresNativeDrError(
+      "TARGET_AUTHORITY_INSUFFICIENT",
+      "PostgreSQL native restore v1 requires a superuser DBA authority"
+    );
+  }
+}
+async function markTargetOffline(client, databaseName) {
+  try {
+    await client.query(`ALTER DATABASE ${quoteSqlIdentifier(databaseName)} WITH ALLOW_CONNECTIONS false`);
+    await client.query(`SELECT pg_catalog.pg_terminate_backend(pid)
+      FROM pg_catalog.pg_stat_activity WHERE datname=$1`, [databaseName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restorePostgresNativeDrInternal(options) {
+  if (options.acceptSourceSqlRisk !== true) {
+    throw new PostgresNativeDrError("SOURCE_SQL_RISK_NOT_ACCEPTED", "PostgreSQL native restore requires explicit acceptance of source SQL risk");
+  }
+  const schema = validatePostgresNativeDrSchema(options.schema);
+  const env = options.environment ?? process.env;
+  const targetUrl = requiredEnvironmentUrl(env, "AGENT_BRIDGE_DR_TARGET_DATABASE_URL");
+  const dumpPath = resolve2(options.dumpPath);
+  const rolesPath = resolve2(options.rolesPath);
+  const deps = dependencies(options.dependencies);
+  const verifiedArtifacts = await verifyPostgresNativeDrArtifacts({
+    dumpPath,
+    rolesPath,
+    schema,
+    artifactAnchors: options.artifactAnchors,
+    toolDirectory: options.toolDirectory,
+    dependencies: deps
+  });
+  const inventory = verifiedArtifacts.roleInventory;
+  const libpqParent = resolve2(rolesPath, "..");
+  verifyPrivatePathAccess(libpqParent, "directory");
+  const libpqDirectory = mkdtempSync(join(libpqParent, ".postgres-dr-libpq-"));
+  securePrivatePath(libpqDirectory, "directory");
+  verifyPrivatePathAccess(libpqDirectory, "directory");
+  let target;
+  let admin;
+  let transactionOpen = false;
+  const createdRoles = [];
+  let targetName = schema.databaseName;
+  let restoreStarted = false;
+  let restoreLockHeld = false;
+  let restoreCompleted = false;
+  let primaryFailure;
+  let phase = "target preflight";
+  try {
+    const libpq = createPostgresDrLibpqFiles(targetUrl, libpqDirectory);
+    target = deps.createClient(targetUrl);
+    await target.connect();
+    const restoreLock = await target.query(
+      "SELECT pg_catalog.pg_try_advisory_lock($1) AS acquired",
+      [NATIVE_DR_ADVISORY_LOCK_KEY]
+    );
+    if (!restoreLock.rows[0]?.acquired) throw new PostgresNativeDrError("RESTORE_IN_PROGRESS", "another native restore already holds the target fence");
+    restoreLockHeld = true;
+    const metadata = await targetMetadata(target);
+    targetName = metadata.databaseName;
+    const major = serverMajor(metadata.serverVersionNum);
+    if (metadata.databaseName !== schema.databaseName) throw new PostgresNativeDrError("DATABASE_NAME_MISMATCH", "target database name must exactly match the backup");
+    if (major !== schema.serverMajor) throw new PostgresNativeDrError("SERVER_MAJOR_MISMATCH", "target PostgreSQL major must exactly match the backup");
+    if (metadata.schemaExists || !metadata.databaseFresh) {
+      throw new PostgresNativeDrError("TARGET_NOT_FRESH", "target must be a dedicated fresh database without user objects or default ACLs");
+    }
+    const conflicts = await target.query(
+      `SELECT rolname AS name FROM pg_catalog.pg_roles WHERE rolname=ANY($1::text[]) ORDER BY rolname`,
+      [inventory.roles.map((role) => role.name)]
+    );
+    if (conflicts.rows.length > 0) throw new PostgresNativeDrError("TARGET_ROLE_CONFLICT", "target contains a role required by the backup");
+    await assertPostgresRestoreAuthority(target);
+    admin = deps.createClient(administrativeDatabaseUrl(targetUrl, metadata.databaseName));
+    await admin.connect();
+    const pgRestore = deps.resolveTool("pg_restore", options.toolDirectory);
+    const schemaAclListPath = join(libpqDirectory, "schema-acl.list");
+    writeFileSync(schemaAclListPath, schemaAclRestoreList(verifiedArtifacts.dumpToc), { encoding: "utf8", mode: 384, flag: "wx" });
+    securePrivatePath(schemaAclListPath, "file");
+    verifyPrivatePathAccess(schemaAclListPath, "file");
+    for (const [index, statement] of buildPostgresRoleShellStatements(inventory).entries()) {
+      phase = "role shell creation";
+      restoreStarted = true;
+      await target.query(statement);
+      createdRoles.push(inventory.roles[index].name);
+    }
+    const schemaOwner = inventory.roles.find((role) => role.kind === "schema-owner");
+    phase = "schema creation";
+    await target.query(`CREATE SCHEMA agent_bridge AUTHORIZATION ${quoteIdentifier(schemaOwner.name)}`);
+    phase = "schema ACL restore";
+    const schemaAclRestore = await runToolWithAnchoredInput(
+      dumpPath,
+      verifiedArtifacts.artifactAnchors.dump,
+      (descriptor) => deps.runTool(
+        pgRestore,
+        buildPgRestoreSchemaAclArgs(void 0, schemaAclListPath, libpq.serviceName),
+        libpq.environment,
+        descriptor
+      )
+    );
+    assertToolSucceeded(schemaAclRestore, "PG_SCHEMA_ACL_RESTORE_FAILED", "pg_restore schema ACL");
+    phase = "pg_restore";
+    const restored = await runToolWithAnchoredInput(
+      dumpPath,
+      verifiedArtifacts.artifactAnchors.dump,
+      (descriptor) => deps.runTool(
+        pgRestore,
+        buildPgRestoreArgs(void 0, libpq.serviceName),
+        libpq.environment,
+        descriptor
+      )
+    );
+    assertToolSucceeded(restored, "PG_RESTORE_FAILED", "pg_restore");
+    await target.query("BEGIN");
+    transactionOpen = true;
+    phase = "membership restore";
+    for (const statement of buildPostgresMembershipStatements(inventory, major)) await target.query(statement);
+    phase = "default privilege restore";
+    for (const statement of buildPostgresDefaultPrivilegeStatements(inventory)) await target.query(statement);
+    phase = "claim normalization";
+    const normalized = await target.query(`
+      WITH changed AS (
+        UPDATE agent_bridge.deliveries SET state='retrying', lease_token=NULL, lease_owner=NULL,
+          lease_expires_at=NULL, available_at=pg_catalog.now(),
+          last_error='lease invalidated by native restore', last_actor='agent-bridge', last_action='lease_expired'
+        WHERE state='claimed' RETURNING 1
+      ) SELECT count(*)::text AS count FROM changed`);
+    const normalizedCount = normalized.rows[0]?.count;
+    if (normalizedCount !== schema.claimedDeliveryCount) throw new PostgresNativeDrError("CLAIM_NORMALIZATION_MISMATCH", "restored claimed delivery count does not match the backup");
+    phase = "migration validation";
+    const migrationRows = await target.query(
+      `SELECT version,name,checksum FROM agent_bridge.schema_migrations ORDER BY version`
+    );
+    const migrations = migrationRows.rows.map((row) => ({ version: Number(row.version), name: row.name, checksum: row.checksum }));
+    if (migrations.length !== schema.migrations.length || migrations.some((migration, index) => {
+      const expected = schema.migrations[index];
+      return expected === void 0 || migration.version !== expected.version || migration.name !== expected.name || migration.checksum !== expected.checksum;
+    })) {
+      throw new PostgresNativeDrError("RESTORE_MIGRATION_MISMATCH", "restored migrations do not match the backup");
+    }
+    phase = "table count validation";
+    const counts = await targetTableCounts(target);
+    compareStringMaps(counts, expectedRestoredTableCounts(schema), "restored PostgreSQL");
+    phase = "readiness validation";
+    const readiness = await target.query(`
+      SELECT agent_bridge.security_schema_ready() AS security,
+        agent_bridge.owner_control_plane_ready() AS "ownerControl",
+        agent_bridge.portable_archive_ready() AS "portableArchive",
+        agent_bridge.credential_security_prerequisite_definition() AS "securityDefinition",
+        agent_bridge.row_isolation_catalog_definition() AS "rowIsolationDefinition",
+        agent_bridge.owner_control_attestation_definition() AS "ownerControlDefinition",
+        agent_bridge.portable_archive_attestation_definition() AS "portableArchiveDefinition"`);
+    const ready = readiness.rows[0];
+    const restoredRowReady = await deps.checkRowIsolationReady(target);
+    const failedReadiness = [
+      !ready?.security ? "security" : void 0,
+      !restoredRowReady ? "row-isolation" : void 0,
+      !ready?.ownerControl ? "owner-control" : void 0,
+      !ready?.portableArchive ? "portable-archive" : void 0
+    ].filter(Boolean);
+    if (failedReadiness.length > 0) {
+      throw new PostgresNativeDrError("RESTORE_NOT_READY", `restored PostgreSQL schema failed readiness attestation: ${failedReadiness.join(", ")}`);
+    }
+    const restoredAttestations = {
+      securitySchemaSha256: sha256(ready.securityDefinition),
+      rowIsolationSha256: sha256(ready.rowIsolationDefinition),
+      ownerControlSha256: sha256(ready.ownerControlDefinition),
+      portableArchiveSha256: sha256(ready.portableArchiveDefinition)
+    };
+    const attestationKeys = [
+      "securitySchemaSha256",
+      "rowIsolationSha256",
+      "ownerControlSha256",
+      "portableArchiveSha256"
+    ];
+    if (attestationKeys.some((key) => restoredAttestations[key] !== schema.readinessAttestations[key])) {
+      throw new PostgresNativeDrError("RESTORE_ATTESTATION_MISMATCH", "restored PostgreSQL readiness attestations do not match the backup");
+    }
+    const externalRoles = inventory.roles.filter((role) => role.kind === "external-principal").map((role) => role.name);
+    if (externalRoles.length > 0) {
+      const loginRoles = await target.query(
+        `SELECT rolname AS name FROM pg_catalog.pg_roles WHERE rolname=ANY($1::text[]) AND rolcanlogin ORDER BY rolname`,
+        [externalRoles]
+      );
+      if (loginRoles.rows.length > 0) throw new PostgresNativeDrError("EXTERNAL_ROLE_CAN_LOGIN", "restored external principals must remain NOLOGIN");
+    }
+    await target.query("COMMIT");
+    transactionOpen = false;
+    const result = {
+      databaseName: metadata.databaseName,
+      normalizedClaimedDeliveries: normalizedCount,
+      tableCounts: counts,
+      readiness: { security: true, rowIsolation: true, ownerControl: true, portableArchive: true }
+    };
+    restoreCompleted = true;
+    return result;
+  } catch (error) {
+    if (transactionOpen && target) await target.query("ROLLBACK").catch(() => void 0);
+    const targetOffline = restoreStarted && admin ? await markTargetOffline(admin, targetName) : false;
+    const original = error instanceof PostgresNativeDrError ? error : void 0;
+    if (restoreStarted && !targetOffline) {
+      primaryFailure = new PostgresNativeDrError(
+        "TARGET_OFFLINE_FAILED",
+        `PostgreSQL native restore failed and the target could not be forced offline${original ? ` after ${original.code}` : ""}`,
+        {
+          residualRoleShells: createdRoles,
+          targetOffline: false,
+          targetMutated: restoreStarted,
+          restoreCompleted: false
+        }
+      );
+      throw primaryFailure;
+    }
+    primaryFailure = new PostgresNativeDrError(
+      original?.code ?? "POSTGRES_NATIVE_RESTORE_FAILED",
+      original?.message ?? `PostgreSQL native restore failed during ${phase}: ${sanitizedUnexpectedError(error, targetUrl)}`,
+      {
+        residualRoleShells: createdRoles,
+        targetOffline,
+        targetMutated: restoreStarted,
+        restoreCompleted: false
+      }
+    );
+    throw primaryFailure;
+  } finally {
+    if (restoreLockHeld && target) {
+      await target.query("SELECT pg_catalog.pg_advisory_unlock($1)", [NATIVE_DR_ADVISORY_LOCK_KEY]).catch(() => void 0);
+    }
+    await target?.end().catch(() => void 0);
+    await admin?.end().catch(() => void 0);
+    try {
+      deps.removePath(libpqDirectory);
+    } catch {
+      if (existsSync(libpqDirectory)) {
+        throw new PostgresNativeDrError(
+          "CREDENTIAL_CLEANUP_FAILED",
+          `PostgreSQL native restore ${restoreCompleted ? "completed" : "failed"}, but its credential directory could not be removed`,
+          {
+            residualRoleShells: primaryFailure?.details.residualRoleShells,
+            targetOffline: primaryFailure?.details.targetOffline,
+            targetMutated: restoreStarted,
+            restoreCompleted,
+            recoveryPaths: [libpqDirectory],
+            causeCode: primaryFailure?.code
+          }
+        );
+      }
+    }
+  }
+}
+async function restorePostgresNativeDr(options) {
+  try {
+    return await restorePostgresNativeDrInternal(options);
+  } catch (error) {
+    if (error instanceof PostgresNativeDrError) {
+      if (typeof error.details.targetMutated === "boolean" && typeof error.details.restoreCompleted === "boolean") {
+        throw error;
+      }
+      throw new PostgresNativeDrError(error.code, error.message, {
+        ...error.details,
+        targetMutated: false,
+        restoreCompleted: false
+      });
+    }
+    throw new PostgresNativeDrError(
+      "POSTGRES_NATIVE_RESTORE_FAILED",
+      "PostgreSQL native restore failed before target mutation",
+      { targetMutated: false, restoreCompleted: false }
+    );
+  }
+}
+
+// src/sqlite-native-dr.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  closeSync as closeSync3,
+  constants as constants3,
+  existsSync as existsSync2,
+  fsyncSync as fsyncSync2,
+  linkSync,
+  lstatSync as lstatSync3,
+  openSync as openSync3,
+  unlinkSync
+} from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
+import { Worker } from "worker_threads";
+var require2 = createRequire(import.meta.url);
+var SQLITE_ENTRY = "sqlite/database.sqlite3";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
+var WORKER_TERMINATION_TIMEOUT_MS = 5e3;
+var NativeDrCommandError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+};
+function fail(code, message, details) {
+  throw new NativeDrCommandError(code, message, details);
+}
+function validateNativeDrId(value) {
+  const normalized = value.toLowerCase();
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(normalized)) {
+    throw new NativeDrCommandError("INVALID_REQUEST_ID", "DR request and backup IDs must be UUIDs");
+  }
+  return normalized;
+}
+function validateNativeDrTimeout(value) {
+  const selected = value ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isSafeInteger(selected) || selected < 100 || selected > MAX_TIMEOUT_MS) {
+    throw new NativeDrCommandError("INVALID_TIMEOUT", "DR timeout must be an integer from 100 to 86400000 milliseconds");
+  }
+  return selected;
+}
+function syncDirectory(path) {
+  if (process.platform === "win32") return;
+  const descriptor = openSync3(path, "r");
+  try {
+    fsyncSync2(descriptor);
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+function operations(options) {
+  return {
+    link: options.fileOperations?.link ?? linkSync,
+    unlink: options.fileOperations?.unlink ?? unlinkSync,
+    syncDirectory: options.fileOperations?.syncDirectory ?? syncDirectory,
+    afterPublish: options.fileOperations?.afterPublish
+  };
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function database(path, readOnly = true) {
+  const { DatabaseSync } = require2("node:sqlite");
+  return new DatabaseSync(path, { readOnly });
+}
+function verifyLocalDatabase(path) {
+  const target = preparePrivateSqliteLocation(path);
+  const before = lstatSync3(target);
+  const db = database(target);
+  try {
+    assertLocalAuthorityDatabase(db);
+    verifySqliteHealth(db);
+    const contract = sqliteSchemaContractHash(db);
+    const after = lstatSync3(target);
+    if (!sameIdentity(before, after)) throw new SQLiteDatabaseContractError("SQLite database path changed while verifying");
+    return contract;
+  } finally {
+    db.close();
+  }
+}
+async function prepareBackupSource(path) {
+  const source = preparePrivateSqliteLocation(path);
+  if (!existsSync2(source)) fail("SOURCE_NOT_FOUND", "local DR source does not exist");
+  let db;
+  let kind = "unknown";
+  try {
+    db = database(source);
+    kind = identifySqliteDatabase(db);
+    if (kind === "edge-cache" || kind === "legacy-edge") fail("EDGE_DATABASE_REJECTED", "edge databases are not supported by native DR v1");
+    if (kind !== "local-authority" && kind !== "legacy-local") fail("INVALID_SOURCE", "DR source is not a local authority database");
+    if (kind === "local-authority") {
+      assertLocalAuthorityDatabase(db);
+      verifySqliteHealth(db);
+    }
+  } finally {
+    db?.close();
+  }
+  if (kind === "legacy-local") {
+    const store = new SQLiteBridgeStore(source);
+    try {
+      await store.initialize();
+    } finally {
+      await store.close();
+    }
+    verifyLocalDatabase(source);
+  }
+  return source;
+}
+var BACKUP_WORKER = String.raw`
+const { parentPort, workerData } = require("node:worker_threads");
+const { DatabaseSync, backup } = require("node:sqlite");
+const { lstatSync } = require("node:fs");
+(async () => {
+  let source;
+  try {
+    const before = lstatSync(workerData.source);
+    if (before.dev !== workerData.identity.dev || before.ino !== workerData.identity.ino) throw new Error("source identity changed");
+    source = new DatabaseSync(workerData.source, { readOnly: true });
+    const pages = await backup(source, workerData.destination, { rate: 64 });
+    source.close(); source = undefined;
+    const after = lstatSync(workerData.source);
+    if (after.dev !== workerData.identity.dev || after.ino !== workerData.identity.ino) throw new Error("source identity changed");
+    parentPort.postMessage({ ok: true, pages });
+  } catch (error) {
+    try { source?.close(); } catch {}
+    parentPort.postMessage({ ok: false, code: error && typeof error.code === "string" ? error.code : "SQLITE_BACKUP_FAILED" });
+  }
+})();`;
+async function runSqliteBackupWorker(source, destination, timeoutMs) {
+  const identity = lstatSync3(source);
+  const worker = new Worker(BACKUP_WORKER, { eval: true, workerData: { source, destination, identity: { dev: identity.dev, ino: identity.ino } } });
+  return await new Promise((resolvePromise, reject) => {
+    let settled = false;
+    const finish = async (callback) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        await Promise.race([
+          worker.terminate(),
+          new Promise((_resolve, rejectTermination) => {
+            const terminationTimer = setTimeout(() => rejectTermination(new Error("worker termination timed out")), WORKER_TERMINATION_TIMEOUT_MS);
+            terminationTimer.unref();
+          })
+        ]);
+      } catch {
+        reject(new NativeDrCommandError(
+          "SQLITE_BACKUP_TERMINATION_UNKNOWN",
+          "SQLite backup worker termination could not be confirmed",
+          { workerTermination: "unknown", recoveryPaths: [destination] }
+        ));
+        return;
+      }
+      callback();
+    };
+    const timer = setTimeout(() => {
+      void finish(() => reject(new NativeDrCommandError("SQLITE_BACKUP_TIMEOUT", "SQLite online backup exceeded its hard deadline")));
+    }, timeoutMs);
+    timer.unref();
+    worker.once("message", (message) => void finish(() => {
+      if (!message?.ok || !Number.isSafeInteger(message.pages)) reject(new NativeDrCommandError("SQLITE_BACKUP_FAILED", "SQLite online backup failed"));
+      else resolvePromise(message.pages);
+    }));
+    worker.once("error", () => void finish(() => reject(new NativeDrCommandError("SQLITE_BACKUP_FAILED", "SQLite online backup worker failed"))));
+    worker.once("exit", (code) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        reject(new NativeDrCommandError("SQLITE_BACKUP_FAILED", `SQLite online backup worker exited before completion (${code})`));
+      }
+    });
+  });
+}
+function cleanup(paths) {
+  for (const path of paths) {
+    try {
+      if (existsSync2(path)) unlinkSync(path);
+    } catch {
+    }
+  }
+  return paths.filter(existsSync2);
+}
+function verifyBundle(path) {
+  const reader = new NativeDrBundleReader(path);
+  try {
+    const result = reader.inspect();
+    if (result.manifest.kind !== "sqlite" || result.manifest.entries.length !== 1 || result.manifest.entries[0].name !== SQLITE_ENTRY || result.manifest.schema.applicationId !== LOCAL_SQLITE_APPLICATION_ID || result.manifest.schema.userVersion !== SQLITE_DATABASE_SCHEMA_VERSION || typeof result.manifest.schema.schemaContractSha256 !== "string" || !isSupportedLocalSqliteSchemaContract(result.manifest.schema.schemaContractSha256)) {
+      throw new NativeDrBundleError("DR bundle is not a supported local SQLite backup");
+    }
+    return result;
+  } finally {
+    reader.close();
+  }
+}
+async function backupLocalSqlite(sourcePath, outputPath, backupIdInput = randomUUID2(), options = {}) {
+  const backupId = validateNativeDrId(backupIdInput);
+  const timeoutMs = validateNativeDrTimeout(options.timeoutMs);
+  const source = await prepareBackupSource(sourcePath);
+  const sourceIdentity = lstatSync3(source);
+  const target = resolve3(outputPath);
+  const directory = dirname2(target);
+  preparePrivateFileLocation(target);
+  const snapshot = join2(directory, `.${backupId}.agent-bridge-dr.sqlite.tmp`);
+  const bundle = join2(directory, `.${backupId}.agent-bridge-dr.bundle.tmp`);
+  const existingRecoveryPaths = [bundle, snapshot].filter(existsSync2);
+  if (existingRecoveryPaths.length) fail("DR_RECOVERY_REQUIRED", "a prior DR backup with this ID requires recovery", {
+    backupId,
+    output: target,
+    outputExists: existsSync2(target),
+    published: existsSync2(target) ? "unknown" : false,
+    recoveryPaths: existingRecoveryPaths
+  });
+  if (existsSync2(target)) fail("OUTPUT_EXISTS", "DR output already exists");
+  let bundleDescriptor;
+  let published = false;
+  let durable = false;
+  const fileOps = operations(options);
+  try {
+    await (options.runBackupWorker ?? runSqliteBackupWorker)(source, snapshot, timeoutMs);
+    securePrivateSqliteFiles(snapshot);
+    const schemaContractSha256 = verifyLocalDatabase(snapshot);
+    const afterBackup = lstatSync3(source);
+    if (sourceIdentity.dev !== afterBackup.dev || sourceIdentity.ino !== afterBackup.ino) fail("SOURCE_CHANGED", "DR source path changed during online backup");
+    bundleDescriptor = openSync3(bundle, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL, 384);
+    securePrivatePath(bundle, "file");
+    writeNativeDrBundle(bundleDescriptor, {
+      backupId,
+      createdAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      entries: [{ name: SQLITE_ENTRY, path: snapshot }],
+      kind: "sqlite",
+      schema: { applicationId: LOCAL_SQLITE_APPLICATION_ID, userVersion: SQLITE_DATABASE_SCHEMA_VERSION, schemaContractSha256 }
+    }, bundle);
+    closeSync3(bundleDescriptor);
+    bundleDescriptor = void 0;
+    const beforePublication = verifyBundle(bundle);
+    try {
+      fileOps.link(bundle, target);
+      published = true;
+    } catch (error) {
+      if (error.code === "EEXIST") fail("OUTPUT_EXISTS", "DR output already exists");
+      throw error;
+    }
+    try {
+      fileOps.afterPublish?.(target);
+      fileOps.syncDirectory(directory);
+      durable = true;
+    } catch {
+      fail("DR_PUBLICATION_AMBIGUOUS", "DR output is visible but durability is unknown", { backupId, output: target, published: true, durable: "unknown", recoveryPaths: [bundle, snapshot].filter(existsSync2) });
+    }
+    let publishedMetadata;
+    try {
+      publishedMetadata = verifyBundle(target);
+    } catch {
+      fail("DR_PUBLICATION_INVALID", "published DR output could not be verified", { backupId, output: target, published: true, durable: true, verified: false, recoveryPaths: [bundle, snapshot].filter(existsSync2) });
+    }
+    if (publishedMetadata.bundleSha256 !== beforePublication.bundleSha256) {
+      fail("DR_PUBLICATION_INVALID", "published DR output does not match its verified staging bundle", { backupId, output: target, published: true, durable: true, verified: false, recoveryPaths: [bundle, snapshot].filter(existsSync2) });
+    }
+    try {
+      fileOps.unlink(bundle);
+      fileOps.unlink(snapshot);
+      fileOps.syncDirectory(directory);
+    } catch {
+      fail("DR_RECOVERY_ARTIFACT_RETAINED", "DR output is valid but a recovery artifact remains", { backupId, output: target, published: true, durable: true, verified: true, recoveryPaths: [bundle, snapshot].filter(existsSync2) });
+    }
+    return publishedMetadata;
+  } catch (error) {
+    if (bundleDescriptor !== void 0) {
+      closeSync3(bundleDescriptor);
+      bundleDescriptor = void 0;
+    }
+    if (!published) {
+      const retainPossiblyActiveSnapshot = error instanceof NativeDrCommandError && error.code === "SQLITE_BACKUP_TERMINATION_UNKNOWN";
+      const recoveryPaths = retainPossiblyActiveSnapshot ? [bundle, snapshot].filter(existsSync2) : cleanup([bundle, snapshot]);
+      if (error instanceof NativeDrCommandError) {
+        throw new NativeDrCommandError(error.code, error.message, recoveryPaths.length ? { ...error.details, backupId, recoveryPaths } : error.details);
+      }
+      fail("DR_BACKUP_FAILED", "local SQLite backup failed", recoveryPaths.length ? { backupId, recoveryPaths } : { backupId });
+    }
+    if (error instanceof NativeDrCommandError) throw error;
+    if (published) fail("DR_PUBLICATION_AMBIGUOUS", "DR publication outcome is incomplete", { backupId, output: target, published: true, durable: durable || "unknown", recoveryPaths: [bundle, snapshot].filter(existsSync2) });
+  } finally {
+    if (bundleDescriptor !== void 0) closeSync3(bundleDescriptor);
+  }
+  throw new NativeDrCommandError("DR_BACKUP_FAILED", "local SQLite backup failed");
+}
+function verifyNativeDrBundle(path) {
+  try {
+    return verifyBundle(path);
+  } catch (error) {
+    if (error instanceof NativeDrCommandError) throw error;
+    fail("INVALID_DR_BUNDLE", "DR bundle verification failed");
+  }
+}
+async function restoreLocalSqlite(bundlePath, targetPath, requestIdInput = randomUUID2(), options = {}) {
+  const requestId = validateNativeDrId(requestIdInput);
+  validateNativeDrTimeout(options.timeoutMs);
+  const bundle = resolve3(bundlePath);
+  const metadata = verifyBundle(bundle);
+  const target = resolve3(targetPath);
+  const directory = dirname2(target);
+  preparePrivateFileLocation(target);
+  const staged = join2(directory, `.${requestId}.agent-bridge-dr.restore.sqlite.tmp`);
+  if (existsSync2(staged)) fail("DR_RECOVERY_REQUIRED", "a prior DR restore with this ID requires recovery", {
+    requestId,
+    target,
+    targetExists: existsSync2(target),
+    published: existsSync2(target) ? "unknown" : false,
+    recoveryPaths: [staged]
+  });
+  if (existsSync2(target) || existsSync2(`${target}-wal`) || existsSync2(`${target}-shm`)) fail("TARGET_EXISTS", "DR restore target must be fresh");
+  let descriptor;
+  let published = false;
+  let durable = false;
+  const fileOps = operations(options);
+  try {
+    descriptor = openSync3(staged, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL, 384);
+    securePrivatePath(staged, "file");
+    const reader = new NativeDrBundleReader(bundle);
+    try {
+      const extracted = reader.inspect((entry) => entry.name === SQLITE_ENTRY ? descriptor : void 0);
+      if (extracted.bundleSha256 !== metadata.bundleSha256) throw new NativeDrBundleError("DR bundle changed between verification passes");
+    } finally {
+      reader.close();
+    }
+    fsyncSync2(descriptor);
+    closeSync3(descriptor);
+    descriptor = void 0;
+    securePrivateSqliteFiles(staged);
+    const restoredContract = verifyLocalDatabase(staged);
+    if (restoredContract !== metadata.manifest.schema.schemaContractSha256) throw new NativeDrBundleError("restored SQLite schema contract does not match the manifest");
+    try {
+      fileOps.link(staged, target);
+      published = true;
+    } catch (error) {
+      if (error.code === "EEXIST") fail("TARGET_EXISTS", "DR restore target must be fresh");
+      throw error;
+    }
+    try {
+      fileOps.afterPublish?.(target);
+      fileOps.syncDirectory(directory);
+      durable = true;
+    } catch {
+      fail("DR_RESTORE_AMBIGUOUS", "restored database is visible but durability is unknown", { requestId, target, published: true, durable: "unknown", verified: false, recoveryPaths: [staged] });
+    }
+    try {
+      const publishedContract = verifyLocalDatabase(target);
+      if (publishedContract !== metadata.manifest.schema.schemaContractSha256) throw new NativeDrBundleError("published SQLite schema contract does not match the manifest");
+    } catch {
+      fail("DR_RESTORE_INVALID", "restored database is visible but failed verification", { requestId, target, published: true, durable: true, verified: false, recoveryPaths: [staged] });
+    }
+    try {
+      fileOps.unlink(staged);
+    } catch {
+      fail("DR_RECOVERY_ARTIFACT_RETAINED", "restored database is valid but a recovery artifact remains", {
+        requestId,
+        target,
+        published: true,
+        durable: true,
+        verified: true,
+        recoveryPaths: [staged].filter(existsSync2)
+      });
+    }
+    try {
+      securePrivateSqliteFiles(target);
+      if (verifyLocalDatabase(target) !== metadata.manifest.schema.schemaContractSha256) {
+        throw new NativeDrBundleError("published SQLite schema contract changed during cleanup");
+      }
+    } catch {
+      fail("DR_RESTORE_INVALID", "restored database failed post-cleanup verification", {
+        requestId,
+        target,
+        published: true,
+        durable: true,
+        verified: false,
+        recoveryPaths: []
+      });
+    }
+    try {
+      fileOps.syncDirectory(directory);
+    } catch {
+      fail("DR_CLEANUP_DURABILITY_UNKNOWN", "restored database is valid but staging cleanup durability is unknown", {
+        requestId,
+        target,
+        published: true,
+        durable: true,
+        verified: true,
+        recoveryPaths: []
+      });
+    }
+    return { ...metadata, requestId };
+  } catch (error) {
+    if (descriptor !== void 0) {
+      closeSync3(descriptor);
+      descriptor = void 0;
+    }
+    if (!published) {
+      const recoveryPaths = cleanup([staged]);
+      if (error instanceof NativeDrCommandError) {
+        throw new NativeDrCommandError(error.code, error.message, recoveryPaths.length ? { ...error.details, requestId, recoveryPaths } : error.details);
+      }
+      fail("DR_RESTORE_FAILED", "local SQLite restore failed", recoveryPaths.length ? { requestId, recoveryPaths } : { requestId });
+    }
+    if (error instanceof NativeDrCommandError) throw error;
+    if (published) fail("DR_RESTORE_AMBIGUOUS", "DR restore outcome is incomplete", { requestId, target, published: true, durable: durable || "unknown", verified: false, recoveryPaths: [staged].filter(existsSync2) });
+  } finally {
+    if (descriptor !== void 0) closeSync3(descriptor);
+  }
+  throw new NativeDrCommandError("DR_RESTORE_FAILED", "local SQLite restore failed");
+}
+var SQLITE_EDGE_APPLICATION_ID = EDGE_SQLITE_APPLICATION_ID;
+
+export {
+  NATIVE_DR_MAX_BUNDLE_BYTES,
+  NATIVE_DR_FORMAT,
+  NATIVE_DR_VERSION,
+  NativeDrBundleError,
+  validateNativeDrAggregateSize,
+  writeNativeDrBundle,
+  NativeDrBundleReader,
+  POSTGRES_NATIVE_DR_ROLE_SCHEMA,
+  POSTGRES_NATIVE_DR_ROLE_VERSION,
+  POSTGRES_NATIVE_DR_SERVICE,
+  POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES,
+  PostgresNativeDrError,
+  createPostgresDrLibpqFiles,
+  buildPgDumpArgs,
+  buildPgRestoreArgs,
+  buildPgRestoreListArgs,
+  buildPgRestoreSchemaAclArgs,
+  validatePostgresDumpToc,
+  schemaAclRestoreList,
+  parsePostgresToolMajor,
+  validatePostgresRoleInventory,
+  canonicalPostgresRoleInventory,
+  buildPostgresRoleShellStatements,
+  buildPostgresMembershipStatements,
+  buildPostgresDefaultPrivilegeStatements,
+  collectPostgresRoleInventory,
+  backupPostgresNativeDr,
+  verifyPostgresNativeDrArtifacts,
+  assertPostgresRestoreAuthority,
+  restorePostgresNativeDr,
+  NativeDrCommandError,
+  validateNativeDrId,
+  validateNativeDrTimeout,
+  runSqliteBackupWorker,
+  backupLocalSqlite,
+  verifyNativeDrBundle,
+  restoreLocalSqlite,
+  SQLITE_EDGE_APPLICATION_ID
+};
+//# sourceMappingURL=chunk-MBPZXTJA.js.map