@crvouga/mockingbird-service-postgres 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog — @crvouga/mockingbird-service-postgres
 
+## 1.7.0 (2026-10-02)
+
+### Features
+
+- coordinate HTTP and protocol mocks ([3168653](https://github.com/crvouga/mockingbird/commit/31686534c55a9823fdaa92afc9cc456cf741b809))
+
+### Fixes and improvements
+
+- decouple smoke types from built packages ([a4b31c6](https://github.com/crvouga/mockingbird/commit/a4b31c6205d92aa0c6f7c9de3518d5ae44d38829))
+- protect child admin endpoints ([5410b94](https://github.com/crvouga/mockingbird/commit/5410b948a30dcedc21e9a70e44fd415c1ea25394))
+- explain discovery and controls ([dd0fed6](https://github.com/crvouga/mockingbird/commit/dd0fed6f5f94cac51ae71f2d2e7d58a6b01ccc63))
+- harden protocol startup and state ([6f5b557](https://github.com/crvouga/mockingbird/commit/6f5b557e87b48b31985949e04f3b5ef58f51d295))
+- preserve checkpoints and lifecycle ([50e8c32](https://github.com/crvouga/mockingbird/commit/50e8c322feded2f7f45afce9d8cdef43c37ab9ab))
+- clean branch state on reset ([3b714d4](https://github.com/crvouga/mockingbird/commit/3b714d4a5df8e75fee0bb31e98d7c7566e164381))
+- type signal listener cleanup ([5279852](https://github.com/crvouga/mockingbird/commit/5279852e56ea60262ccf17aa6e46b3c31091a34a))
+
 ## 1.6.0 (2026-10-01)
 
 ### Features
@@ -36,6 +52,7 @@
 - allow unpopulated materialized views to reference each other ([3ce1d8f](https://github.com/crvouga/mockingbird/commit/3ce1d8f555ed4008dd894aed20ebf64ab0253774))
 - support CREATE EXTENSION pg_trgm ([2296ba2](https://github.com/crvouga/mockingbird/commit/2296ba2f3d1a9ea7ce8ec9f528e979034692ebf1))
 - install pgcrypto digest() ([b5f3ccf](https://github.com/crvouga/mockingbird/commit/b5f3ccf79c6fedcabab157f1ee07af18a7871057))
+- boot Bolt over Socket Mode ([01322df](https://github.com/crvouga/mockingbird/commit/01322df315c66b1f2f5b53094cbbeeeef6d3ae6c))
 
 ## 1.3.1 (2026-09-29)
 

package/COMPATIBILITY.md

@@ -10,6 +10,10 @@ See [COMPATIBILITY-AUDIT.md](COMPATIBILITY-AUDIT.md) for the latest evidence-bas
 
 Reference oracle: **PostgreSQL 18.3** via PGlite (`@electric-sql/pglite`, real Postgres compiled to WASM, in-process). Inventory: `bun run inventory`. Construct catalog: `bun run scenarios` → [`compat/scenarios.ts`](compat/scenarios.ts). Divergences: [`compat/divergences.json`](compat/divergences.json). Requirements matrix: `bun run requirements` → `compat/requirements.json` + `compat/coverage.json`.
 
+The Node `/server` entry participates in protocol fleets. Acceptance tests use `pg@8.23.0`
+for authenticated readiness, shutdown, namespace isolation, full-catalog reset/snapshot/restore and
+clock controls. This supervisor surface does not change the SQL dialect compatibility contract.
+
 ## Proof surface
 
 Differential tests compare a **tuple** per statement: rows (normalized to canonical PostgreSQL text where typed), column names and type names where requested, error SQLSTATE class + normalized message, command tag / `rowCount`, and transaction status, plus a **logical state dump** (catalog names, column definitions, row payloads, sequence values) after write sequences.

package/README.md

@@ -193,6 +193,13 @@ server from one frozen template, so a seeded stack starts from the same bytes ea
 surface as every other mock, including the table explorer (`GET /sql/tables`, `POST /sql/query`).
 The wire server does not speak that HTTP API.
 
+`mockingbird-postgres serve --config mockingbird.json` also supervises a mixed HTTP/Postgres/Redis
+fleet through the Node `/server` entry. See [fleet configuration and controls](../../../docs/FLEETS.md)
+for ephemeral discovery, namespace endpoints, aggregate health, snapshots and clocks. Each declared
+namespace has an independent cluster. Fleet checkpoints restore its entire catalog, including created
+and dropped databases, records, deterministic random state, faults and time; live client sessions
+return a conflict until closed.
+
 `server.snapshot()` freezes the live state; `server.fault({ dropConnection | delayStatementMs |
 failCommit })` arms the next statement or connection for a drop, a delay, or a `40001` commit
 failure.

package/dist/admin.js

@@ -1561,29 +1561,30 @@ var createControlPlane = (context) => {
       return json(200, { status: "ok", reset: target === "*" ? context.namespaces() : [target] });
     },
     "GET /namespaces": () => json(200, { default: context.defaultNamespace, namespaces: context.namespaces() }),
-    "GET /clock": () => json(200, context.clock.state()),
-    "POST /clock": ({ body }) => {
+    "GET /clock": ({ namespace }) => json(200, (context.namespaceClock?.(namespace) ?? context.clock).state()),
+    "POST /clock": ({ body, namespace }) => {
+      const clock = context.namespaceClock?.(namespace) ?? context.clock;
       if (!isRecord2(body))
         return adminError(400, "expected a JSON object");
       if (body.reset === true)
-        context.clock.reset();
+        clock.reset();
       if (body.freeze === true)
-        context.clock.freeze();
+        clock.freeze();
       if (body.set !== void 0) {
         const instant = parseInstant(body.set);
         if (instant === void 0)
           return adminError(400, "set: expected epoch ms or ISO-8601");
-        context.clock.set(instant);
+        clock.set(instant);
       }
       if (body.advance !== void 0) {
         const delta = parseDuration(body.advance);
         if (delta === void 0)
           return adminError(400, 'advance: expected ms or "15m"-style');
-        context.clock.advance(delta);
+        clock.advance(delta);
       }
       if (body.freeze === false)
-        context.clock.unfreeze();
-      return json(200, context.clock.state());
+        clock.unfreeze();
+      return json(200, clock.state());
     },
     "GET /faults": () => json(200, { faults: context.faults.list() }),
     "POST /faults": ({ body, namespace }) => {
@@ -2425,7 +2426,33 @@ var faultResponse = (rule) => {
 };
 var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
   const entries = [];
+  let isolated = false;
+  const scopedRngs = /* @__PURE__ */ new Map();
+  const random = (namespace) => {
+    if (!isolated || namespace === "default")
+      return rng;
+    let scoped = scopedRngs.get(namespace);
+    if (!scoped) {
+      scoped = createRng(rng.seed);
+      scopedRngs.set(namespace, scoped);
+    }
+    return scoped;
+  };
   return {
+    isolateNamespaces() {
+      isolated = true;
+    },
+    snapshot(namespace) {
+      return {
+        rules: structuredClone(entries.map((entry, position) => ({
+          ...entry.rule,
+          remaining: entry.remaining,
+          hits: entry.hits,
+          position
+        })).filter((entry) => entry.namespace === namespace)),
+        rngState: random(namespace).state()
+      };
+    },
     add(rule) {
       const existing = entries.findIndex((e) => e.rule.id === rule.id);
       const entry = { rule, remaining: rule.count ?? null, hits: 0 };
@@ -2445,6 +2472,16 @@ var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((reso
     },
     clear() {
       entries.length = 0;
+      rng.reset();
+      scopedRngs.clear();
+    },
+    restore(namespace, state) {
+      for (let i = entries.length - 1; i >= 0; i--)
+        if (entries[i]?.rule.namespace === namespace)
+          entries.splice(i, 1);
+      for (const { remaining, hits, position, ...rule } of state.rules)
+        entries.splice(Math.min(position, entries.length), 0, { rule, remaining, hits });
+      random(namespace).setState(state.rngState);
     },
     async take(candidate) {
       const hits = [];
@@ -2454,7 +2491,7 @@ var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((reso
         if (!matches(entry.rule, candidate))
           continue;
         const rate = entry.rule.rate ?? 1;
-        if (rng.next() >= rate)
+        if (random(candidate.namespace).next() >= rate)
           continue;
         entry.hits++;
         if (entry.remaining !== null)
@@ -2521,7 +2558,8 @@ var createJournal = (size = DEFAULT_JOURNAL_SIZE) => {
 };
 
 // ../core/dist/metrics.js
-var createMetrics = () => {
+var createMetrics = (partition = true) => {
+  const namespaces = /* @__PURE__ */ new Map();
   let requests = 0;
   let faults = 0;
   let totalDurationMs = 0;
@@ -2529,6 +2567,14 @@ var createMetrics = () => {
   const unmatched = /* @__PURE__ */ new Map();
   return {
     record(entry) {
+      if (partition) {
+        let scoped = namespaces.get(entry.namespace);
+        if (!scoped) {
+          scoped = createMetrics(false);
+          namespaces.set(entry.namespace, scoped);
+        }
+        scoped.record(entry);
+      }
       requests++;
       totalDurationMs += entry.durationMs;
       if (entry.faultId !== void 0)
@@ -2540,7 +2586,7 @@ var createMetrics = () => {
         unmatched.set(route, (unmatched.get(route) ?? 0) + 1);
       }
     },
-    report: () => ({
+    report: (namespace) => namespace !== void 0 ? (namespaces.get(namespace) ?? createMetrics(false)).report() : {
       requests,
       byOperation: Object.fromEntries([...byOperation].sort(([a], [b]) => a.localeCompare(b))),
       unmatched: [...unmatched].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([route, count]) => {
@@ -2549,8 +2595,13 @@ var createMetrics = () => {
       }),
       faults,
       totalDurationMs
-    }),
-    reset() {
+    },
+    reset(namespace) {
+      if (namespace !== void 0) {
+        namespaces.delete(namespace);
+        return;
+      }
+      namespaces.clear();
       requests = 0;
       faults = 0;
       totalDurationMs = 0;