@creatornader/agent-bridge 0.3.1 → 0.5.0

package/dist/{chunk-MBPZXTJA.js → chunk-7VJI2MXI.js}

@@ -10,18 +10,18 @@ import {
   isSupportedLocalSqliteSchemaContract,
   sqliteSchemaContractHash,
   verifySqliteHealth
-} from "./chunk-5GMB3A77.js";
+} from "./chunk-IVG4XWWS.js";
 import {
   preparePrivateFileLocation,
   preparePrivateSqliteLocation,
   securePrivatePath,
   securePrivateSqliteFiles,
   verifyPrivatePathAccess
-} from "./chunk-NCO7RLBM.js";
+} from "./chunk-GTK4KOED.js";
 import {
   NATIVE_DR_ADVISORY_LOCK_KEY,
   rowIsolationReady
-} from "./chunk-45BZGB77.js";
+} from "./chunk-QNXHDOJ5.js";
 
 // src/native-dr-bundle.ts
 import { createHash } from "crypto";
@@ -88,12 +88,19 @@ var POSTGRES_SCHEMA_FIELDS = [
   "claimedDeliveryCount",
   "readinessAttestations"
 ];
-var POSTGRES_EXCLUDED_DATA = [
+var POSTGRES_LEGACY_EXCLUDED_DATA = [
   "agent_bridge.agent_instances",
   "agent_bridge.rate_limit_buckets",
   "agent_bridge.request_authorities",
   "agent_bridge.archive_transaction_authorizations"
 ];
+var POSTGRES_EXCLUDED_DATA = [
+  ...POSTGRES_LEGACY_EXCLUDED_DATA,
+  "agent_bridge.endpoint_migration_challenges"
+];
+function postgresExcludedDataForSchemaVersion(schemaVersion) {
+  return schemaVersion <= 17 ? POSTGRES_LEGACY_EXCLUDED_DATA : POSTGRES_EXCLUDED_DATA;
+}
 function validateSchema(kind, value) {
   if (kind === "sqlite") {
     const schema2 = exactObject(value, ["applicationId", "schemaContractSha256", "userVersion"], "DR SQLite schema");
@@ -106,7 +113,7 @@ function validateSchema(kind, value) {
   }
   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");
+  if (!Array.isArray(schema.migrations) || schema.migrations.length === 0 || 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");
@@ -115,13 +122,17 @@ function validateSchema(kind, value) {
     }
     priorVersion = Number(migration.version);
   }
+  if (priorVersion !== Number(schema.schemaVersion)) {
+    throw new NativeDrBundleError("DR PostgreSQL schema version does not match migrations");
+  }
   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])) {
+  const excludedData = postgresExcludedDataForSchemaVersion(Number(schema.schemaVersion));
+  if (!Array.isArray(schema.excludedDataTables) || schema.excludedDataTables.length !== excludedData.length || schema.excludedDataTables.some((name, index) => name !== excludedData[index])) {
     throw new NativeDrBundleError("DR PostgreSQL excluded-data inventory is invalid");
   }
   const readiness = exactObject(schema.readinessAttestations, [
@@ -453,12 +464,19 @@ function createBoundedToolOutput(maximumBytes) {
 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 = [
+var POSTGRES_NATIVE_DR_LEGACY_EXCLUDED_DATA_TABLES = [
   "agent_bridge.agent_instances",
   "agent_bridge.rate_limit_buckets",
   "agent_bridge.request_authorities",
   "agent_bridge.archive_transaction_authorizations"
 ];
+var POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES = [
+  ...POSTGRES_NATIVE_DR_LEGACY_EXCLUDED_DATA_TABLES,
+  "agent_bridge.endpoint_migration_challenges"
+];
+function excludedDataTablesForSchemaVersion(schemaVersion) {
+  return schemaVersion <= 17 ? POSTGRES_NATIVE_DR_LEGACY_EXCLUDED_DATA_TABLES : POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES;
+}
 var SSL_PARAMETERS = /* @__PURE__ */ new Set([
   "channel_binding",
   "sslcert",
@@ -469,7 +487,7 @@ var SSL_PARAMETERS = /* @__PURE__ */ new Set([
   "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 DERIVED_ROLE = /^agent_bridge_(?:runtime|data_owner|context_reader|event_writer|control_owner|control_operator|control_auditor|archive_operator|backup_reader)_[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;
@@ -579,6 +597,9 @@ function createPostgresDrLibpqFiles(connectionUrl, directory) {
   };
 }
 function buildPgDumpArgs(outputPath, snapshot, serviceName = POSTGRES_NATIVE_DR_SERVICE) {
+  return buildPgDumpArgsForTables(outputPath, snapshot, serviceName, POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES);
+}
+function buildPgDumpArgsForTables(outputPath, snapshot, serviceName, excludedDataTables) {
   assertSafeText(outputPath, "PostgreSQL dump path");
   assertSafeText(snapshot, "PostgreSQL snapshot");
   assertSafeText(serviceName, "PostgreSQL service name");
@@ -588,7 +609,7 @@ function buildPgDumpArgs(outputPath, snapshot, serviceName = POSTGRES_NATIVE_DR_
     "--schema=agent_bridge",
     "--no-tablespaces",
     `--snapshot=${snapshot}`,
-    ...POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES.map((table) => `--exclude-table-data=${table}`),
+    ...excludedDataTables.map((table) => `--exclude-table-data=${table}`),
     `--dbname=service=${serviceName}`
   ];
 }
@@ -661,6 +682,29 @@ var POSTGRES_TOC_DESCRIPTORS = [
   "ACL"
 ];
 var POSTGRES_TOC_MAX_BYTES = 16 * 1024 * 1024;
+function parsePostgresDumpTocBody(entry) {
+  let cursor = 0;
+  const readDigits = () => {
+    const start = cursor;
+    while (cursor < entry.length) {
+      const code = entry.charCodeAt(cursor);
+      if (code < 48 || code > 57) break;
+      cursor += 1;
+    }
+    return cursor > start;
+  };
+  const readSeparator = () => {
+    const start = cursor;
+    while (entry[cursor] === " " || entry[cursor] === "	") cursor += 1;
+    return cursor > start;
+  };
+  if (!readDigits() || entry[cursor] !== ";") return void 0;
+  cursor += 1;
+  if (!readSeparator() || !readDigits() || !readSeparator() || !readDigits() || !readSeparator()) {
+    return void 0;
+  }
+  return cursor < entry.length ? entry.slice(cursor) : void 0;
+}
 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");
@@ -668,9 +712,8 @@ function validatePostgresDumpToc(text) {
   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 body = parsePostgresDumpTocBody(entry);
+    if (body === void 0) throw new PostgresNativeDrError("PG_DUMP_TOC_INVALID", "PostgreSQL dump table of contents has an invalid record");
     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);
@@ -891,21 +934,62 @@ 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) => {
+  const validated = validatePostgresRoleInventory(inventory);
+  const schemaOwner = validated.roles.find((role) => role.kind === "schema-owner");
+  const rolesByName = new Map(validated.roles.map((role) => [role.name, role]));
+  const orderedMemberships = [...validated.memberships].sort((left, right) => {
+    const leftOwnerAuthority = left.member === schemaOwner.name ? 0 : 1;
+    const rightOwnerAuthority = right.member === schemaOwner.name ? 0 : 1;
+    return leftOwnerAuthority - rightOwnerAuthority || left.role.localeCompare(right.role) || left.member.localeCompare(right.member);
+  });
+  return orderedMemberships.filter(
+    (membership) => rolesByName.get(membership.member).kind !== "external-principal"
+  ).map((membership) => {
+    let grant;
     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};`;
+      grant = `GRANT ${quoteIdentifier(membership.role)} TO ${quoteIdentifier(membership.member)}${membership.adminOption ? " WITH ADMIN OPTION" : ""};`;
+    } else {
+      const options = [
+        `ADMIN ${membership.adminOption ? "OPTION" : "FALSE"}`,
+        `INHERIT ${membership.inheritOption ? "TRUE" : "FALSE"}`,
+        `SET ${membership.setOption ? "TRUE" : "FALSE"}`
+      ].join(", ");
+      grant = `GRANT ${quoteIdentifier(membership.role)} TO ${quoteIdentifier(membership.member)} WITH ${options};`;
+    }
+    const role = rolesByName.get(membership.role);
+    const schemaOwnerGrantedDerivedMembership = membership.member !== schemaOwner.name && role.kind === "derived";
+    return schemaOwnerGrantedDerivedMembership ? `SET LOCAL ROLE ${quoteIdentifier(schemaOwner.name)}; ${grant} RESET ROLE;` : grant;
   });
 }
+function suspendedPostgresMemberships(inventory) {
+  const suffix = createHash2("md5").update(inventory.databaseName).digest("hex").slice(0, 16);
+  const recognizedRoles = /* @__PURE__ */ new Map([
+    [`agent_bridge_control_operator_${suffix}`, "operator"],
+    [`agent_bridge_control_auditor_${suffix}`, "auditor"],
+    [`agent_bridge_archive_operator_${suffix}`, "archive"]
+  ]);
+  const rolesByName = new Map(inventory.roles.map((role) => [role.name, role]));
+  const suspended = [];
+  for (const membership of inventory.memberships) {
+    if (rolesByName.get(membership.member)?.kind !== "external-principal") continue;
+    const recognized = recognizedRoles.get(membership.role);
+    if (recognized === "archive") {
+      suspended.push({ kind: "archive", member: membership.member });
+      continue;
+    }
+    if (recognized === "operator" || recognized === "auditor") {
+      suspended.push({
+        kind: "control",
+        member: membership.member,
+        controlRole: recognized
+      });
+    }
+  }
+  return suspended;
+}
 var DEFAULT_PRIVILEGE_OBJECTS = {
   r: "TABLES",
   S: "SEQUENCES",
@@ -1178,7 +1262,8 @@ async function collectPostgresRoleInventory(client, databaseName) {
       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_'
+        'agent_bridge_control_auditor_','agent_bridge_archive_operator_',
+        'agent_bridge_backup_reader_'
       ]) prefix
     ), object_roles AS (
       SELECT namespace.nspowner AS oid, 'schema-owner'::text AS kind
@@ -1257,13 +1342,14 @@ async function collectPostgresRoleInventory(client, databaseName) {
   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"
+      bool_or(membership.admin_option) AS "adminOption",
+      bool_or(coalesce((to_jsonb(membership)->>'inherit_option')::boolean,true)) AS "inheritOption",
+      bool_or(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[])
+    GROUP BY granted.rolname,member.rolname
     ORDER BY granted.rolname,member.rolname`, [names]);
   if (names.length > 0) {
     const boundary = await client.query(`
@@ -1350,9 +1436,13 @@ async function collectSnapshotMetadata(client, checkRowReady) {
     }
   }
   if (migrations.length === 0) throw new PostgresNativeDrError("SOURCE_SCHEMA_EMPTY", "source has no Agent Bridge migrations");
+  const schemaVersion = Math.max(...migrations.map((migration) => migration.version));
   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`);
+    SELECT relation.relname AS "tableName"
+    FROM pg_catalog.pg_class relation
+    JOIN pg_catalog.pg_namespace namespace ON namespace.oid=relation.relnamespace
+    WHERE namespace.nspname='agent_bridge' AND relation.relkind IN ('r','p')
+    ORDER BY relation.relname`);
   const tableCounts = {};
   for (const row of tableRows.rows) {
     const qualified = `agent_bridge.${row.tableName}`;
@@ -1363,6 +1453,9 @@ async function collectSnapshotMetadata(client, checkRowReady) {
     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;
   }
+  if (!tableRows.rows.some((row) => row.tableName === "deliveries")) {
+    throw new PostgresNativeDrError("SOURCE_COUNT_INVALID", "source deliveries table is unavailable");
+  }
   const claimed = await client.query(
     `SELECT count(*)::text AS count FROM agent_bridge.deliveries WHERE state='claimed'`
   );
@@ -1374,13 +1467,15 @@ async function collectSnapshotMetadata(client, checkRowReady) {
     SELECT agent_bridge.security_schema_ready() AS security,
       agent_bridge.owner_control_plane_ready() AS "ownerControl",
       agent_bridge.portable_archive_ready() AS "portableArchive",
+      ${schemaVersion >= 21 ? 'agent_bridge.native_backup_ready() AS "nativeBackup",' : ""}
       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") {
+  const authorityReady = await gatewayAuthorityReady(client, schemaVersion);
+  if (!ready?.security || !rowReady || !ready.ownerControl || !ready.portableArchive || schemaVersion >= 21 && !ready.nativeBackup || !authorityReady || 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 {
@@ -1397,6 +1492,105 @@ async function collectSnapshotMetadata(client, checkRowReady) {
     }
   };
 }
+async function gatewayAuthorityReady(client, schemaVersion) {
+  if (schemaVersion <= 16) return true;
+  const result = await client.query(`
+    WITH names AS (
+      SELECT ('agent_bridge_runtime_' || substr(md5(current_database()),1,16))::name AS runtime_role,
+        (SELECT nspowner FROM pg_catalog.pg_namespace WHERE nspname='agent_bridge') AS schema_owner
+    ) SELECT
+      agent_bridge.gateway_authority_ready()
+      AND EXISTS (
+        SELECT 1
+        FROM pg_catalog.pg_class relation
+        JOIN pg_catalog.pg_namespace namespace ON namespace.oid=relation.relnamespace
+        WHERE namespace.nspname='agent_bridge' AND relation.relname='gateway_authority'
+          AND relation.relkind='r' AND relation.relowner=(SELECT schema_owner FROM names)
+          AND NOT relation.relrowsecurity AND NOT relation.relforcerowsecurity
+      )
+      AND EXISTS (
+        SELECT 1 FROM pg_catalog.pg_constraint table_constraint
+        WHERE table_constraint.conrelid='agent_bridge.gateway_authority'::regclass
+          AND table_constraint.conname='gateway_authority_singleton'
+          AND table_constraint.contype='p'
+          AND table_constraint.conkey::smallint[]=ARRAY[(SELECT attribute.attnum FROM pg_catalog.pg_attribute attribute
+            WHERE attribute.attrelid='agent_bridge.gateway_authority'::regclass
+              AND attribute.attname='singleton' AND attribute.attnum>0 AND NOT attribute.attisdropped)]
+      )
+      AND EXISTS (
+        SELECT 1 FROM pg_catalog.pg_constraint table_constraint
+        WHERE table_constraint.conrelid='agent_bridge.gateway_authority'::regclass
+          AND table_constraint.conname='gateway_authority_singleton_true'
+          AND table_constraint.contype='c'
+          AND regexp_replace(
+            pg_get_expr(table_constraint.conbin,table_constraint.conrelid),'[[:space:]()]','','g'
+          )='singleton'
+      )
+      AND EXISTS (
+        SELECT 1 FROM pg_catalog.pg_constraint table_constraint
+        WHERE table_constraint.conrelid='agent_bridge.gateway_authority'::regclass
+          AND table_constraint.conname='gateway_authority_id_unique'
+          AND table_constraint.contype='u'
+          AND table_constraint.conkey::smallint[]=ARRAY[(SELECT attribute.attnum FROM pg_catalog.pg_attribute attribute
+            WHERE attribute.attrelid='agent_bridge.gateway_authority'::regclass
+              AND attribute.attname='authority_id' AND attribute.attnum>0 AND NOT attribute.attisdropped)]
+      )
+      AND EXISTS (
+        SELECT 1
+        FROM pg_catalog.pg_trigger trigger
+        JOIN pg_catalog.pg_proc trigger_function ON trigger_function.oid=trigger.tgfoid
+        JOIN pg_catalog.pg_namespace trigger_namespace ON trigger_namespace.oid=trigger_function.pronamespace
+        WHERE trigger.tgrelid='agent_bridge.gateway_authority'::regclass
+          AND trigger.tgname='gateway_authority_immutable'
+          AND NOT trigger.tgisinternal AND trigger.tgenabled='O'
+          AND (trigger.tgtype::integer & 1)=0
+          AND (trigger.tgtype::integer & 2)=2
+          AND (trigger.tgtype::integer & 56)=56
+          AND trigger_function.proname='reject_gateway_authority_mutation'
+          AND trigger_namespace.nspname='agent_bridge'
+          AND trigger_function.proowner=(SELECT schema_owner FROM names)
+          AND NOT trigger_function.prosecdef
+          AND coalesce(trigger_function.proconfig @> ARRAY['search_path=""'],false)
+      )
+      AND EXISTS (
+        SELECT 1 FROM pg_catalog.pg_proc procedure
+        WHERE procedure.oid='agent_bridge.gateway_authority_ready()'::regprocedure
+          AND procedure.prosecdef AND procedure.provolatile='s'
+          AND procedure.proowner=(SELECT schema_owner FROM names)
+          AND coalesce(procedure.proconfig @> ARRAY['search_path=""'],false)
+      )
+      AND EXISTS (
+        SELECT 1 FROM pg_catalog.pg_proc procedure
+        WHERE procedure.oid='agent_bridge.open_request_authority_bound(uuid,text,uuid)'::regprocedure
+          AND procedure.prosecdef AND procedure.provolatile='v'
+          AND procedure.proowner=(SELECT schema_owner FROM names)
+          AND coalesce(procedure.proconfig @> ARRAY['search_path=""'],false)
+      )
+      AND NOT EXISTS (
+        SELECT 1
+        FROM unnest(ARRAY[
+          'SELECT','INSERT','UPDATE','DELETE','TRUNCATE','REFERENCES','TRIGGER'
+        ]) privilege(value)
+        WHERE has_table_privilege((SELECT runtime_role FROM names),
+          'agent_bridge.gateway_authority',privilege.value)
+          OR has_table_privilege('public','agent_bridge.gateway_authority',privilege.value)
+      )
+      AND NOT EXISTS (
+        SELECT 1
+        FROM unnest(ARRAY['SELECT','INSERT','UPDATE','REFERENCES']) privilege(value)
+        WHERE has_any_column_privilege((SELECT runtime_role FROM names),
+          'agent_bridge.gateway_authority',privilege.value)
+          OR has_any_column_privilege('public','agent_bridge.gateway_authority',privilege.value)
+      )
+      AND has_function_privilege((SELECT runtime_role FROM names),
+        'agent_bridge.gateway_authority_ready()','EXECUTE')
+      AND has_function_privilege((SELECT runtime_role FROM names),
+        'agent_bridge.open_request_authority_bound(uuid,text,uuid)','EXECUTE')
+      AND NOT has_function_privilege('public','agent_bridge.gateway_authority_ready()','EXECUTE')
+      AND NOT has_function_privilege('public',
+        'agent_bridge.open_request_authority_bound(uuid,text,uuid)','EXECUTE') AS ready`);
+  return result.rows[0]?.ready === true;
+}
 function createPrivateEmptyFile(path) {
   const descriptor = openSync2(path, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL, 384);
   closeSync2(descriptor);
@@ -1434,10 +1628,16 @@ async function backupPostgresNativeDr(options) {
     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 schemaVersion = Math.max(...metadata.migrations.map((migration) => migration.version));
+    const excludedDataTables = excludedDataTablesForSchemaVersion(schemaVersion);
     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);
+    const dump = await deps.runTool(
+      tools.pgDump,
+      buildPgDumpArgsForTables(dumpPath, snapshot, libpq.serviceName, excludedDataTables),
+      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");
@@ -1459,7 +1659,6 @@ async function backupPostgresNativeDr(options) {
     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(),
@@ -1471,7 +1670,7 @@ async function backupPostgresNativeDr(options) {
         schemaVersion,
         migrations: metadata.migrations,
         tableCounts: metadata.tableCounts,
-        excludedDataTables: [...POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES],
+        excludedDataTables: [...excludedDataTables],
         claimedDeliveryCount: metadata.claimedDeliveryCount,
         pgDumpVersion: tools.pgDumpVersion,
         roleInventorySha256: sha256(canonicalRoles),
@@ -1558,10 +1757,11 @@ function validatePostgresNativeDrSchema(value) {
       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]) {
+  const excludedDataTables = excludedDataTablesForSchemaVersion(value.schemaVersion);
+  for (const table of ["agent_bridge.deliveries", "agent_bridge.delivery_events", ...excludedDataTables]) {
     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)) {
+  if (JSON.stringify(value.excludedDataTables) !== JSON.stringify(excludedDataTables)) {
     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");
@@ -1669,12 +1869,24 @@ async function targetTableCounts(client) {
   }
   return counts;
 }
-function expectedRestoredTableCounts(schema) {
+function expectedRestoredTableCounts(schema, suspendedMemberships) {
   const expected = { ...schema.tableCounts };
-  for (const table of POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES) expected[table] = "0";
+  for (const table of excludedDataTablesForSchemaVersion(schema.schemaVersion)) 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();
+  for (const [kind, table] of [
+    ["control", "agent_bridge.control_membership_events"],
+    ["archive", "agent_bridge.archive_membership_events"]
+  ]) {
+    const increment = suspendedMemberships.filter((membership) => membership.kind === kind).length;
+    if (increment === 0) continue;
+    const current = expected[table];
+    if (current === void 0) {
+      throw new PostgresNativeDrError("INVALID_MANIFEST", `PostgreSQL ${kind} membership event count is missing`);
+    }
+    expected[table] = (BigInt(current) + BigInt(increment)).toString();
+  }
   return expected;
 }
 function compareStringMaps(actual, expected, label) {
@@ -1765,11 +1977,17 @@ async function restorePostgresNativeDrInternal(options) {
     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 schemaOwner = inventory.roles.find((role) => role.kind === "schema-owner");
     const conflicts = await target.query(
-      `SELECT rolname AS name FROM pg_catalog.pg_roles WHERE rolname=ANY($1::text[]) ORDER BY rolname`,
+      `SELECT rolname AS name,rolname=current_user AS "isCurrentUser",
+         rolsuper "isSuperuser"
+       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");
+    const reusesSchemaOwner = conflicts.rows.length === 1 && conflicts.rows[0]?.name === schemaOwner.name && conflicts.rows[0].isCurrentUser && conflicts.rows[0].isSuperuser;
+    if (conflicts.rows.length > 0 && !reusesSchemaOwner) {
+      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();
@@ -1779,12 +1997,13 @@ async function restorePostgresNativeDrInternal(options) {
     securePrivatePath(schemaAclListPath, "file");
     verifyPrivatePathAccess(schemaAclListPath, "file");
     for (const [index, statement] of buildPostgresRoleShellStatements(inventory).entries()) {
+      const role = inventory.roles[index];
+      if (reusesSchemaOwner && role.name === schemaOwner.name) continue;
       phase = "role shell creation";
       restoreStarted = true;
       await target.query(statement);
-      createdRoles.push(inventory.roles[index].name);
+      createdRoles.push(role.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";
@@ -1815,6 +2034,25 @@ async function restorePostgresNativeDrInternal(options) {
     transactionOpen = true;
     phase = "membership restore";
     for (const statement of buildPostgresMembershipStatements(inventory, major)) await target.query(statement);
+    const suspendedMemberships = suspendedPostgresMemberships(inventory);
+    phase = "external membership suspension";
+    for (const membership of suspendedMemberships) {
+      if (membership.kind === "control") {
+        await target.query(
+          `INSERT INTO agent_bridge.control_membership_events(
+             request_id,action,member_role,control_role,actor
+           ) VALUES($1::uuid,'revoke',$2::name,$3,$4::name)`,
+          [deps.randomId(), membership.member, membership.controlRole, schemaOwner.name]
+        );
+      } else {
+        await target.query(
+          `INSERT INTO agent_bridge.archive_membership_events(
+             request_id,action,member_role,actor
+           ) VALUES($1::uuid,'revoke',$2::name,$3::name)`,
+          [deps.randomId(), membership.member, schemaOwner.name]
+        );
+      }
+    }
     phase = "default privilege restore";
     for (const statement of buildPostgresDefaultPrivilegeStatements(inventory)) await target.query(statement);
     phase = "claim normalization";
@@ -1840,23 +2078,27 @@ async function restorePostgresNativeDrInternal(options) {
     }
     phase = "table count validation";
     const counts = await targetTableCounts(target);
-    compareStringMaps(counts, expectedRestoredTableCounts(schema), "restored PostgreSQL");
+    compareStringMaps(counts, expectedRestoredTableCounts(schema, suspendedMemberships), "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",
+        ${schema.schemaVersion >= 21 ? 'agent_bridge.native_backup_ready() AS "nativeBackup",' : ""}
         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 restoredGatewayAuthorityReady = await gatewayAuthorityReady(target, schema.schemaVersion);
     const failedReadiness = [
       !ready?.security ? "security" : void 0,
       !restoredRowReady ? "row-isolation" : void 0,
       !ready?.ownerControl ? "owner-control" : void 0,
-      !ready?.portableArchive ? "portable-archive" : void 0
+      !ready?.portableArchive ? "portable-archive" : void 0,
+      schema.schemaVersion >= 21 && !ready?.nativeBackup ? "native-backup" : void 0,
+      !restoredGatewayAuthorityReady ? "gateway-authority" : void 0
     ].filter(Boolean);
     if (failedReadiness.length > 0) {
       throw new PostgresNativeDrError("RESTORE_NOT_READY", `restored PostgreSQL schema failed readiness attestation: ${failedReadiness.join(", ")}`);
@@ -2396,6 +2638,7 @@ export {
   POSTGRES_NATIVE_DR_ROLE_SCHEMA,
   POSTGRES_NATIVE_DR_ROLE_VERSION,
   POSTGRES_NATIVE_DR_SERVICE,
+  POSTGRES_NATIVE_DR_LEGACY_EXCLUDED_DATA_TABLES,
   POSTGRES_NATIVE_DR_EXCLUDED_DATA_TABLES,
   PostgresNativeDrError,
   createPostgresDrLibpqFiles,
@@ -2425,4 +2668,4 @@ export {
   restoreLocalSqlite,
   SQLITE_EDGE_APPLICATION_ID
 };
-//# sourceMappingURL=chunk-MBPZXTJA.js.map
+//# sourceMappingURL=chunk-7VJI2MXI.js.map