lurqrun 0.1.7 → 0.1.8

package/dist/chunk-3D2MPGOQ.js

@@ -0,0 +1,181 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/notify/safeHttp.ts
+init_esm_shims();
+import { lookup as dnsLookup } from "dns";
+import https from "https";
+import { isIP } from "net";
+var MAX_URL = 2e3;
+var TIMEOUT_MS = 1e4;
+var MAX_RESPONSE = 4e3;
+function v4Private(ip) {
+  const [a = 0, b = 0] = ip.split(".").map(Number);
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || // carrier-grade NAT
+  a === 169 && b === 254 || // link-local, cloud metadata
+  a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 192 && b === 0 || a === 198 && (b === 18 || b === 19) || // benchmarking
+  a >= 224;
+}
+function isPrivateAddress(ip) {
+  const kind = isIP(ip);
+  if (kind === 4) return v4Private(ip);
+  if (kind !== 6) return true;
+  const v = ip.toLowerCase();
+  if (v === "::" || v === "::1") return true;
+  const mapped = /^::ffff:(.+)$/.exec(v);
+  if (mapped) {
+    const rest = mapped[1];
+    if (isIP(rest) === 4) return v4Private(rest);
+    const [hi = "0", lo = "0"] = rest.split(":");
+    const n = parseInt(hi, 16) << 16 | parseInt(lo, 16);
+    return v4Private([n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255].join("."));
+  }
+  return /^f[cd]/.test(v) || /^fe[89ab]/.test(v) || v.startsWith("ff");
+}
+var SLACK_HOSTS = /* @__PURE__ */ new Set(["hooks.slack.com"]);
+var DISCORD_HOSTS = /* @__PURE__ */ new Set([
+  "discord.com",
+  "discordapp.com",
+  "ptb.discord.com",
+  "canary.discord.com"
+]);
+var TEAMS_SUFFIXES = [".logic.azure.com", ".powerplatform.com", ".powerautomate.com"];
+function validateChannelUrl(kind, raw) {
+  if (typeof raw !== "string" || !raw.trim() || raw.length > MAX_URL)
+    return { ok: false, error: "Paste the full webhook URL." };
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    return { ok: false, error: "That is not a valid URL." };
+  }
+  if (url.protocol !== "https:") return { ok: false, error: "The URL must start with https://." };
+  if (url.username || url.password)
+    return { ok: false, error: "The URL must not contain a username or password." };
+  const host = url.hostname.toLowerCase();
+  if (kind === "slack") {
+    if (!SLACK_HOSTS.has(host) || !/^\/(services|triggers)\//.test(url.pathname)) {
+      return {
+        ok: false,
+        error: "A Slack incoming webhook URL starts with https://hooks.slack.com/services/."
+      };
+    }
+  } else if (kind === "discord") {
+    if (!DISCORD_HOSTS.has(host) || !url.pathname.startsWith("/api/webhooks/")) {
+      return {
+        ok: false,
+        error: "A Discord webhook URL starts with https://discord.com/api/webhooks/."
+      };
+    }
+  } else if (kind === "teams") {
+    if (host.endsWith(".webhook.office.com") || host === "outlook.office.com") {
+      return {
+        ok: false,
+        error: "Teams retired Office 365 connector webhooks in May 2026. Create one with the Workflows app instead."
+      };
+    }
+    if (!TEAMS_SUFFIXES.some((s) => host.endsWith(s))) {
+      return {
+        ok: false,
+        error: "Use the webhook URL a Teams Workflows flow gives you (a logic.azure.com or powerplatform.com address)."
+      };
+    }
+  } else {
+    if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) {
+      return { ok: false, error: "The URL must be reachable on the public internet." };
+    }
+    if (isIP(host.replace(/^\[|\]$/g, "")) && isPrivateAddress(host.replace(/^\[|\]$/g, ""))) {
+      return { ok: false, error: "The URL must be reachable on the public internet." };
+    }
+  }
+  return { ok: true, url };
+}
+function safeLookup(resolve = dnsLookup) {
+  return (hostname, options, callback) => {
+    resolve(hostname, { all: true }, (err, addresses) => {
+      if (err) return callback(err, []);
+      const list = addresses;
+      if (!list.length || list.some((a) => isPrivateAddress(a.address))) {
+        const e = Object.assign(new Error(`${hostname} resolves to a private network address`), {
+          code: "EPRIVATE"
+        });
+        return callback(e, []);
+      }
+      if (options?.all) return callback(null, list);
+      callback(null, list[0].address, list[0].family);
+    });
+  };
+}
+function postJson(url, payload, headers, opts = {}) {
+  return new Promise((resolvePost) => {
+    let settled = false;
+    const done = (o) => {
+      if (!settled) {
+        settled = true;
+        resolvePost(o);
+      }
+    };
+    let req;
+    try {
+      req = https.request(
+        url,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "lurq-alerts",
+            "Content-Length": Buffer.byteLength(payload),
+            ...headers
+          },
+          lookup: opts.lookup ?? safeLookup(),
+          timeout: opts.timeoutMs ?? TIMEOUT_MS
+        },
+        (res) => {
+          let body = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            if (body.length < MAX_RESPONSE) body += chunk;
+          });
+          res.on("end", () => {
+            const status = res.statusCode ?? 0;
+            done({
+              status,
+              error: status >= 200 && status < 300 ? null : `HTTP ${status}${body ? `: ${body.slice(0, 120).replace(/\s+/g, " ")}` : ""}`
+            });
+          });
+          res.on(
+            "error",
+            () => done({ status: res.statusCode ?? 0, error: "response interrupted" })
+          );
+        }
+      );
+    } catch (err) {
+      done({
+        status: 0,
+        error: err instanceof Error ? err.message : "request failed",
+        code: "EINVAL"
+      });
+      return;
+    }
+    req.on("timeout", () => {
+      req.destroy(Object.assign(new Error("timed out"), { code: "ETIMEDOUT" }));
+    });
+    req.on("error", (err) => {
+      done({
+        status: 0,
+        error: err.code === "EPRIVATE" ? err.message : `could not connect (${err.code ?? err.message})`,
+        code: err.code ?? "ECONNECT"
+      });
+    });
+    req.end(payload);
+  });
+}
+
+export {
+  isPrivateAddress,
+  validateChannelUrl,
+  safeLookup,
+  postJson
+};

package/dist/{chunk-LYMPYETA.js → chunk-4JHDSVIN.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
 import {
   EMBEDDING_DIM
-} from "./chunk-GPTKSNR6.js";
+} from "./chunk-72Y2FDVS.js";
 import {
   __export,
   init_esm_shims
@@ -14,6 +14,7 @@ __export(schema_exports, {
   apiKeys: () => apiKeys,
   apiSurfaces: () => apiSurfaces,
   askSpendDaily: () => askSpendDaily,
+  builderScans: () => builderScans,
   claims: () => claims,
   compatEdges: () => compatEdges,
   compatVerifyQueue: () => compatVerifyQueue,
@@ -23,8 +24,15 @@ __export(schema_exports, {
   mcpChangeEvents: () => mcpChangeEvents,
   mcpContracts: () => mcpContracts,
   mcpDeployments: () => mcpDeployments,
+  mcpEndpointChangeAcks: () => mcpEndpointChangeAcks,
+  mcpEndpointChanges: () => mcpEndpointChanges,
+  mcpEndpointObservations: () => mcpEndpointObservations,
+  mcpEndpointServers: () => mcpEndpointServers,
   mcpObservations: () => mcpObservations,
+  mcpPins: () => mcpPins,
   mcpPublicReports: () => mcpPublicReports,
+  mcpRegistryServers: () => mcpRegistryServers,
+  mcpRemoteEndpoints: () => mcpRemoteEndpoints,
   notificationChannels: () => notificationChannels,
   notificationDeliveries: () => notificationDeliveries,
   notificationItems: () => notificationItems,
@@ -36,6 +44,7 @@ __export(schema_exports, {
   policyDecisions: () => policyDecisions,
   recommendationOutcomes: () => recommendationOutcomes,
   repoAlerts: () => repoAlerts,
+  repoPolicyDefaults: () => repoPolicyDefaults,
   repos: () => repos,
   resolvedClosures: () => resolvedClosures,
   seedPackages: () => seedPackages,
@@ -161,7 +170,17 @@ var packages = pgTable(
      *  Null for crawler/_changes-created packages, or ones ingested before
      *  dashboard accounts existed. Stamped once via a standalone WHERE ... IS NULL
      *  update kept out of upsertPackage, so re-syncs can never clobber it. */
-    firstRequestedByOwnerId: text("first_requested_by_owner_id")
+    firstRequestedByOwnerId: text("first_requested_by_owner_id"),
+    /**
+     * Failed API-surface extractions for `surface_attempted_version`. The worker
+     * stops asking once a version has failed SURFACE_MAX_ATTEMPTS times; a new
+     * latest version starts the count again, since it may ship types the last
+     * one did not. Without this, a package with no extractable surface was
+     * re-attempted at random every hour, forever. Not in upsertPackage's row,
+     * so re-syncs never reset it.
+     */
+    surfaceAttempts: integer("surface_attempts").notNull().default(0),
+    surfaceAttemptedVersion: text("surface_attempted_version")
   },
   (table) => [
     uniqueIndex("packages_ecosystem_name_idx").on(table.ecosystem, table.name),
@@ -211,6 +230,13 @@ var discoveryQueue = pgTable(
      *  and never reaching the write that would take it off the queue. Same
      *  treatment `compat_verify_queue.attempts` already gives a failing set. */
     attempts: integer("attempts").notNull().default(0),
+    /**
+     * The account whose query asked for this package (`reactive` rows only),
+     * credited as first requester when it is ingested. Stored here because the
+     * on-demand ingest used to live only in the API process's memory, and a
+     * deploy mid-backlog dropped both the work and the attribution.
+     */
+    requestedByOwnerId: text("requested_by_owner_id"),
     discoveredAt: ts("discovered_at").notNull().defaultNow()
   },
   (table) => [index("discovery_queue_status_idx").on(table.status)]
@@ -392,6 +418,11 @@ var ownerUsageDaily = pgTable(
     index("owner_usage_daily_owner_date_idx").on(table.ownerId, table.date)
   ]
 );
+var repoPolicyDefaults = pgTable("repo_policy_defaults", {
+  ownerId: text("owner_id").primaryKey(),
+  policy: jsonb("policy").$type().notNull(),
+  updatedAt: ts("updated_at").notNull().defaultNow()
+});
 var repos = pgTable(
   "repos",
   {
@@ -458,6 +489,21 @@ var upgradeRuns = pgTable(
      * row per package+target and updates in place.
      */
     runUrl: text("run_url").notNull().default(""),
+    /**
+     * What started the run, from GITHUB_EVENT_NAME. See `RunTrigger`.
+     *
+     * NULLABLE, and deliberately NOT in the dedup index below. Every row
+     * written before this column existed has no trigger, and back-filling them
+     * with 'schedule' would invent evidence the log then presents as fact — the
+     * same rule `unverified` and `analysedOnly` follow. The dashboard renders
+     * null as "not recorded".
+     *
+     * Keeping it out of the dedup key is not a style choice: `runUrl` is in
+     * that key and is NOT NULL precisely because Postgres treats NULLs as
+     * distinct, so a nullable column there would let every re-post insert a
+     * duplicate instead of updating in place.
+     */
+    trigger: text("trigger").$type(),
     createdAt: ts("created_at").notNull().defaultNow()
   },
   (table) => [
@@ -480,7 +526,10 @@ var repoAlerts = pgTable(
     id: serial("id").primaryKey(),
     /** Clerk user id, copied from the repo — alerts are read owner-scoped. */
     ownerId: text("owner_id").notNull(),
-    repoId: integer("repo_id").notNull(),
+    /** Null for an account that runs `check-upgrade` on a repo lurq has no
+     *  GitHub App installation for: the alert is keyed by `repo_full_name` from
+     *  its upgrade runs instead, and there is no repo page to link to. */
+    repoId: integer("repo_id"),
     /** Denormalized so the feed renders without a join, as in `upgrade_runs`. */
     repoFullName: text("repo_full_name").notNull(),
     packageName: text("package_name").notNull(),
@@ -507,7 +556,11 @@ var repoAlerts = pgTable(
     // One alert per repo per release. A re-sync of the same version — and the
     // watcher re-syncs on every publish, including non-latest backports — must
     // not re-notify.
-    uniqueIndex("repo_alerts_dedup_idx").on(table.repoId, table.packageName, table.toVersion)
+    uniqueIndex("repo_alerts_dedup_idx").on(table.repoId, table.packageName, table.toVersion),
+    // The same rule for alerts with no connected repo. Postgres treats NULLs as
+    // distinct, so the index above can never dedupe those rows; this one covers
+    // exactly them. Partial, so adding it cannot fail on existing rows.
+    uniqueIndex("repo_alerts_cli_dedup_idx").on(table.ownerId, table.repoFullName, table.packageName, table.toVersion).where(sql`repo_id is null`)
   ]
 );
 var surfaceQueue = pgTable(
@@ -532,6 +585,12 @@ var surfaceQueue = pgTable(
     specKey: text("spec_key").notNull().unique(),
     /** Failed drains bump this; the worker drops a spec that keeps failing. */
     attempts: integer("attempts").notNull().default(0),
+    /**
+     * Not eligible before this. Set on every retry with an exponential delay, so
+     * a spec that just failed waits instead of being retried the next cycle and
+     * — oldest-first — blocking every newer spec behind it. Null = ready now.
+     */
+    nextAttemptAt: ts("next_attempt_at"),
     requestedAt: ts("requested_at").notNull().defaultNow()
   },
   (table) => [index("surface_queue_requested_idx").on(table.kind, table.requestedAt)]
@@ -801,7 +860,11 @@ var mcpDeployments = pgTable(
     lastChangedAt: ts("last_changed_at")
   },
   (table) => [
-    uniqueIndex("mcp_deployments_identity_idx").on(table.ownerId, table.serverKey, table.configFingerprint),
+    uniqueIndex("mcp_deployments_identity_idx").on(
+      table.ownerId,
+      table.serverKey,
+      table.configFingerprint
+    ),
     index("mcp_deployments_owner_idx").on(table.ownerId, table.lastScannedAt)
   ]
 );
@@ -854,7 +917,9 @@ var mcpPublicReports = pgTable(
     reportedAt: ts("reported_at").notNull().defaultNow()
   },
   (table) => [
-    primaryKey({ columns: [table.registry, table.packageName, table.version, table.contentHash, table.ownerId] }),
+    primaryKey({
+      columns: [table.registry, table.packageName, table.version, table.contentHash, table.ownerId]
+    }),
     index("mcp_public_reports_version_idx").on(table.registry, table.packageName, table.version)
   ]
 );
@@ -924,6 +989,196 @@ var notificationChannels = pgTable(
   },
   (table) => [index("notification_channels_owner_idx").on(table.ownerId)]
 );
+var builderScans = pgTable(
+  "builder_scans",
+  {
+    ownerId: text("owner_id").notNull(),
+    target: text("target").notNull(),
+    login: text("login").notNull(),
+    archetype: text("archetype").$type().notNull(),
+    avatarUrl: text("avatar_url").notNull(),
+    // What builderStanding.ts ranks on, copied out of `profile` at save, so
+    // ranking reads seven integers per builder instead of every whole report.
+    repos: integer("repos").notNull(),
+    active90: integer("active_90").notNull(),
+    stars: integer("stars").notNull(),
+    depsTracked: integer("deps_tracked").notNull(),
+    depsBehind: integer("deps_behind").notNull(),
+    depsMajor: integer("deps_major").notNull(),
+    advisories: integer("advisories").notNull(),
+    profile: jsonb("profile").$type().notNull(),
+    scannedAt: ts("scanned_at").notNull().defaultNow(),
+    createdAt: ts("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    primaryKey({ columns: [table.ownerId, table.target] }),
+    index("builder_scans_owner_recent_idx").on(table.ownerId, table.scannedAt)
+  ]
+);
+var mcpRegistryServers = pgTable(
+  "mcp_registry_servers",
+  {
+    name: text("name").notNull(),
+    version: text("version").notNull(),
+    title: text("title"),
+    description: text("description"),
+    websiteUrl: text("website_url"),
+    repositoryUrl: text("repository_url"),
+    /** `active`, `deprecated`, `deleted`, … as the registry reports it. */
+    status: text("status").notNull(),
+    isLatest: boolean("is_latest").notNull(),
+    remotes: jsonb("remotes").$type().notNull(),
+    packages: jsonb("packages").$type().notNull(),
+    publishedAt: ts("published_at"),
+    registryUpdatedAt: ts("registry_updated_at"),
+    syncedAt: ts("synced_at").notNull().defaultNow()
+  },
+  (table) => [
+    primaryKey({ columns: [table.name, table.version] }),
+    index("mcp_registry_servers_latest_idx").on(table.name).where(sql`${table.isLatest}`),
+    index("mcp_registry_servers_updated_idx").on(table.registryUpdatedAt)
+  ]
+);
+var mcpRemoteEndpoints = pgTable(
+  "mcp_remote_endpoints",
+  {
+    id: serial("id").primaryKey(),
+    url: text("url").notNull().unique(),
+    host: text("host").notNull(),
+    /** Transport the registry declares: `streamable-http` or `sse`. */
+    transport: text("transport").notNull(),
+    /** URL carries `{placeholders}`: never probed, answered as setup-dependent. */
+    templated: boolean("templated").notNull().default(false),
+    /** A maintainer asked not to be probed. Never scheduled again. */
+    optedOut: boolean("opted_out").notNull().default(false),
+    lastStatus: text("last_status").$type(),
+    lastHttpStatus: integer("last_http_status"),
+    /** Content hash of the last contract read (a key into `mcp_contracts`). */
+    lastContentHash: text("last_content_hash"),
+    /** Hash of the auth profile, so an auth change is detectable without a diff. */
+    lastAuthHash: text("last_auth_hash"),
+    auth: jsonb("auth").$type(),
+    violations: jsonb("violations").$type().notNull().default([]),
+    protocolMode: text("protocol_mode").$type(),
+    protocolVersion: text("protocol_version"),
+    serverName: text("server_name"),
+    serverVersion: text("server_version"),
+    finalUrl: text("final_url"),
+    latencyMs: integer("latency_ms"),
+    lastError: text("last_error"),
+    consecutiveFailures: integer("consecutive_failures").notNull().default(0),
+    probeCount: integer("probe_count").notNull().default(0),
+    firstSeenAt: ts("first_seen_at").notNull().defaultNow(),
+    lastProbedAt: ts("last_probed_at"),
+    lastChangedAt: ts("last_changed_at"),
+    nextProbeAt: ts("next_probe_at").notNull().defaultNow(),
+    leaseUntil: ts("lease_until"),
+    /** No live registry entry names this URL any more. Kept for history. */
+    removedAt: ts("removed_at"),
+    /**
+     * The key an account's own `lurq mcp-scan` gives this server (`remote:<host><path>`,
+     * query dropped). Joining on it is how a change the public probe sees reaches
+     * every account already running the server, without anyone rescanning.
+     */
+    scanKey: text("scan_key")
+  },
+  (table) => [
+    index("mcp_remote_endpoints_scan_key_idx").on(table.scanKey),
+    index("mcp_remote_endpoints_due_idx").on(table.nextProbeAt).where(
+      sql`${table.optedOut} = false and ${table.templated} = false and ${table.removedAt} is null`
+    ),
+    index("mcp_remote_endpoints_host_idx").on(table.host)
+  ]
+);
+var mcpEndpointServers = pgTable(
+  "mcp_endpoint_servers",
+  {
+    endpointId: integer("endpoint_id").notNull().references(() => mcpRemoteEndpoints.id),
+    serverName: text("server_name").notNull(),
+    headers: jsonb("headers").$type().notNull().default([]),
+    lastSeenAt: ts("last_seen_at").notNull().defaultNow(),
+    /**
+     * The server's latest registry version stopped naming this URL, or the
+     * server was deleted. Marked, never deleted: rows in this schema are history.
+     */
+    removedAt: ts("removed_at")
+  },
+  (table) => [
+    primaryKey({ columns: [table.endpointId, table.serverName] }),
+    index("mcp_endpoint_servers_name_idx").on(table.serverName)
+  ]
+);
+var mcpEndpointObservations = pgTable(
+  "mcp_endpoint_observations",
+  {
+    id: serial("id").primaryKey(),
+    endpointId: integer("endpoint_id").notNull().references(() => mcpRemoteEndpoints.id),
+    status: text("status").$type().notNull(),
+    httpStatus: integer("http_status"),
+    contentHash: text("content_hash"),
+    authHash: text("auth_hash"),
+    violations: jsonb("violations").$type().notNull().default([]),
+    protocolVersion: text("protocol_version"),
+    error: text("error"),
+    probeCount: integer("probe_count").notNull().default(1),
+    firstSeenAt: ts("first_seen_at").notNull().defaultNow(),
+    lastSeenAt: ts("last_seen_at").notNull().defaultNow()
+  },
+  (table) => [
+    index("mcp_endpoint_observations_endpoint_idx").on(table.endpointId, table.firstSeenAt)
+  ]
+);
+var mcpEndpointChanges = pgTable(
+  "mcp_endpoint_changes",
+  {
+    id: serial("id").primaryKey(),
+    endpointId: integer("endpoint_id").notNull().references(() => mcpRemoteEndpoints.id),
+    kind: text("kind").$type().notNull(),
+    fromKey: text("from_key").notNull(),
+    toKey: text("to_key").notNull(),
+    severity: text("severity").$type().notNull(),
+    summary: text("summary").notNull(),
+    diff: jsonb("diff").$type(),
+    createdAt: ts("created_at").notNull().defaultNow()
+  },
+  (table) => [
+    uniqueIndex("mcp_endpoint_changes_pair_idx").on(
+      table.endpointId,
+      table.kind,
+      table.fromKey,
+      table.toKey
+    ),
+    index("mcp_endpoint_changes_endpoint_idx").on(table.endpointId, table.createdAt),
+    index("mcp_endpoint_changes_created_idx").on(table.createdAt)
+  ]
+);
+var mcpPins = pgTable(
+  "mcp_pins",
+  {
+    id: serial("id").primaryKey(),
+    ownerId: text("owner_id").notNull(),
+    endpointId: integer("endpoint_id").notNull().references(() => mcpRemoteEndpoints.id),
+    /** Null when the contract was not readable without credentials at pin time. */
+    contentHash: text("content_hash"),
+    authHash: text("auth_hash"),
+    note: text("note"),
+    pinnedAt: ts("pinned_at").notNull().defaultNow(),
+    removedAt: ts("removed_at")
+  },
+  (table) => [
+    uniqueIndex("mcp_pins_owner_endpoint_idx").on(table.ownerId, table.endpointId),
+    index("mcp_pins_endpoint_idx").on(table.endpointId)
+  ]
+);
+var mcpEndpointChangeAcks = pgTable(
+  "mcp_endpoint_change_acks",
+  {
+    ownerId: text("owner_id").notNull(),
+    changeId: integer("change_id").notNull().references(() => mcpEndpointChanges.id),
+    acknowledgedAt: ts("acknowledged_at").notNull().defaultNow()
+  },
+  (table) => [primaryKey({ columns: [table.ownerId, table.changeId] })]
+);
 
 export {
   packages,
@@ -940,6 +1195,7 @@ export {
   recommendationOutcomes,
   askSpendDaily,
   ownerUsageDaily,
+  repoPolicyDefaults,
   repos,
   upgradeRuns,
   repoAlerts,
@@ -961,5 +1217,13 @@ export {
   mcpPublicReports,
   notificationPreferences,
   notificationChannels,
+  builderScans,
+  mcpRegistryServers,
+  mcpRemoteEndpoints,
+  mcpEndpointServers,
+  mcpEndpointObservations,
+  mcpEndpointChanges,
+  mcpPins,
+  mcpEndpointChangeAcks,
   schema_exports
 };