@crvouga/mockingbird-service-prism 1.7.1 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog — @crvouga/mockingbird-service-prism
 
+## 1.8.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))
+- 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.7.1 (2026-10-01)
 
 ### Fixes and improvements

package/dist/{chunk-OZBUWLPY.js → chunk-EJSDM62Y.js}

@@ -183,29 +183,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 (!isRecord(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 }) => {
@@ -474,7 +475,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 };
@@ -494,6 +521,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 = [];
@@ -503,7 +540,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)
@@ -1071,7 +1108,8 @@ var annotateResponse = (response, extra) => {
 var responseNotes = (response) => notes.get(response);
 
 // ../core/dist/metrics.js
-var createMetrics = () => {
+var createMetrics = (partition = true) => {
+  const namespaces = /* @__PURE__ */ new Map();
   let requests = 0;
   let faults = 0;
   let totalDurationMs = 0;
@@ -1079,6 +1117,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)
@@ -1090,7 +1136,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]) => {
@@ -1099,8 +1145,13 @@ var createMetrics = () => {
       }),
       faults,
       totalDurationMs
-    }),
-    reset() {
+    },
+    reset(namespace) {
+      if (namespace !== void 0) {
+        namespaces.delete(namespace);
+        return;
+      }
+      namespaces.clear();
       requests = 0;
       faults = 0;
       totalDurationMs = 0;
@@ -4072,7 +4123,7 @@ var stateAdminRoutes = (routes) => {
 };
 
 // ../core/dist/version.js
-var PACKAGE_VERSION = true ? "1.7.1" : UNRELEASED_VERSION;
+var PACKAGE_VERSION = true ? "1.8.0" : UNRELEASED_VERSION;
 
 // ../core/dist/webhooks.js
 var json4 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
@@ -4238,6 +4289,20 @@ var createRuntime = (options) => {
   const instances = /* @__PURE__ */ new Map();
   const publicNamespaces = /* @__PURE__ */ new Set();
   const branchRngs = /* @__PURE__ */ new Map();
+  const namespaceClocks = /* @__PURE__ */ new Map();
+  const namespaceForStorage = /* @__PURE__ */ new Map();
+  let isolatedNamespaces = false;
+  const namespaceClock = (name = DEFAULT_NAMESPACE) => {
+    if (!isolatedNamespaces || name === DEFAULT_NAMESPACE)
+      return clock;
+    let found = namespaceClocks.get(name);
+    if (!found) {
+      found = createClock();
+      namespaceClocks.set(name, found);
+    }
+    return found;
+  };
+  const fleetPoints = /* @__PURE__ */ new WeakMap();
   const timelines = /* @__PURE__ */ new Map();
   const branchStorage = /* @__PURE__ */ new Map();
   const captured = /* @__PURE__ */ new Map();
@@ -4251,17 +4316,21 @@ var createRuntime = (options) => {
     if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
       throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
     }
+    const createdContextRng = isolatedRng ?? (isolatedNamespaces && key !== DEFAULT_NAMESPACE ? createRng(options.seed ?? 0) : rng);
     const created = options.create({
       namespace: storageNamespace(key),
       publicNamespace,
       sqlite,
-      clock,
-      rng: isolatedRng ?? rng
+      clock: namespaceClock(publicNamespace),
+      rng: createdContextRng
     });
     instances.set(key, created);
+    namespaceForStorage.set(key, publicNamespace);
     publicNamespaces.add(publicNamespace);
     if (isolatedRng)
       branchRngs.set(key, isolatedRng);
+    else if (isolatedNamespaces && key !== DEFAULT_NAMESPACE)
+      branchRngs.set(key, createdContextRng);
     return created;
   };
   const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
@@ -4279,7 +4348,7 @@ var createRuntime = (options) => {
     captured.set(storage, snapshot2);
     return Object.freeze({
       snapshot: snapshot2,
-      clock: Object.freeze(clock.state()),
+      clock: Object.freeze(namespaceClock(namespaceForStorage.get(storage) ?? storage).state()),
       rngState: (branchRngs.get(storage) ?? rng).state()
     });
   };
@@ -4289,7 +4358,7 @@ var createRuntime = (options) => {
       return found;
     instance(name);
     found = new Timeline({
-      now: clock.now,
+      now: namespaceClock(name).now,
       ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
     });
     found.commit(capture(name));
@@ -4316,12 +4385,13 @@ var createRuntime = (options) => {
         const point = history2.checkout("main", at);
         restoreNamespace(sqlite, storageNamespace(namespace), point.value.snapshot);
         captured.set(namespace, point.value.snapshot);
-        rng.setState(point.value.rngState);
-        clock.set(point.value.clock.now);
+        (branchRngs.get(namespace) ?? rng).setState(point.value.rngState);
+        const selectedClock = namespaceClock(namespace);
+        selectedClock.set(point.value.clock.now);
         if (point.value.clock.frozen)
-          clock.freeze();
+          selectedClock.freeze();
         else
-          clock.unfreeze();
+          selectedClock.unfreeze();
       }
       return namespace;
     }
@@ -4379,11 +4449,12 @@ var createRuntime = (options) => {
     const storage = ensureBranch(namespace, branchName);
     restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
     captured.set(storage, point.value.snapshot);
-    clock.set(point.value.clock.now);
+    const selectedClock = namespaceClock(namespace);
+    selectedClock.set(point.value.clock.now);
     if (point.value.clock.frozen)
-      clock.freeze();
+      selectedClock.freeze();
     else
-      clock.unfreeze();
+      selectedClock.unfreeze();
     (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
   };
   const reset = async (name = DEFAULT_NAMESPACE) => {
@@ -4391,10 +4462,21 @@ var createRuntime = (options) => {
       options.webhooks?.clear();
       for (const each of instances.values())
         await each.reset();
+      for (const each of branchRngs.values())
+        each.reset();
       timelines.clear();
+      for (const storage of branchStorage.values()) {
+        instances.delete(storage);
+        branchRngs.delete(storage);
+        namespaceForStorage.delete(storage);
+      }
       branchStorage.clear();
-      branchRngs.clear();
       captured.clear();
+      faults.clear();
+      clock.reset();
+      rng.reset();
+      for (const each of namespaceClocks.values())
+        each.reset();
       return;
     }
     options.webhooks?.clear(name);
@@ -4412,11 +4494,18 @@ var createRuntime = (options) => {
       else
         clearNamespace(sqlite, storageNamespace(storage));
       branchStorage.delete(mapping);
+      instances.delete(storage);
+      namespaceForStorage.delete(storage);
       branchRngs.delete(storage);
       captured.delete(storage);
     }
     timelines.delete(name);
     captured.delete(name);
+    faults.restore(name, { rules: [], rngState: createRng(options.seed ?? 0).state() });
+    namespaceClock(name).reset();
+    (branchRngs.get(name) ?? rng).reset();
+    journal.clear(name);
+    metrics.reset(name);
   };
   const snapshot = (name = DEFAULT_NAMESPACE) => {
     return checkpoint(name, "main").value.snapshot;
@@ -4454,6 +4543,53 @@ var createRuntime = (options) => {
     rng,
     credentials,
     webhooks: options.webhooks,
+    isolateNamespaces() {
+      if (publicNamespaces.size > 1)
+        throw new Error("enable namespace isolation before creating named namespaces");
+      isolatedNamespaces = true;
+      faults.isolateNamespaces();
+    },
+    namespaceClock,
+    namespaceOf(request) {
+      const url = new URL(request.url);
+      const prefixed = PATH_PREFIX.exec(url.pathname);
+      const selected = request.headers.get(NAMESPACE_HEADER) ?? (prefixed ? decodeURIComponent(prefixed[1]) : void 0);
+      const path = prefixed ? prefixed[2] ?? "/" : url.pathname;
+      if (path === "/__admin" || path.startsWith("/__admin/"))
+        return url.searchParams.get("namespace") ?? selected ?? DEFAULT_NAMESPACE;
+      if (selected !== void 0)
+        return selected;
+      const credential = options.credential?.(request);
+      return (credential !== void 0 ? credentials.get(credential) : void 0) ?? DEFAULT_NAMESPACE;
+    },
+    fleetSnapshot(namespace) {
+      instance(namespace);
+      const handle = {};
+      fleetPoints.set(handle, {
+        namespace,
+        state: capture(namespace),
+        faults: faults.snapshot(namespace),
+        webhooks: options.webhooks?.snapshot(namespace)
+      });
+      return handle;
+    },
+    fleetRestore(handle, namespace) {
+      const point = typeof handle === "object" && handle !== null ? fleetPoints.get(handle) : void 0;
+      if (!point || point.namespace !== namespace)
+        throw new Error("invalid fleet checkpoint");
+      restoreNamespace(sqlite, storageNamespace(namespace), point.state.snapshot);
+      captured.set(namespace, point.state.snapshot);
+      const selectedClock = namespaceClock(namespace);
+      selectedClock.freeze();
+      selectedClock.set(point.state.clock.now);
+      if (!point.state.clock.frozen)
+        selectedClock.unfreeze();
+      (branchRngs.get(namespace) ?? rng).setState(point.state.rngState);
+      faults.restore(namespace, point.faults);
+      if (point.webhooks !== void 0)
+        options.webhooks?.restore(namespace, point.webhooks);
+      timelines.delete(namespace);
+    },
     applyPreset: (name, namespace = DEFAULT_NAMESPACE, overrides = {}) => {
       const preset = options.presets?.[name];
       if (!preset)
@@ -4629,6 +4765,7 @@ var createRuntime = (options) => {
     startedAt: wallNow(),
     wallNow,
     clock,
+    namespaceClock,
     faults,
     metrics,
     journal,
@@ -5351,6 +5488,8 @@ var PrismAPI = class {
 };
 
 export {
+  createClock,
+  parseDuration,
   document2 as document,
   operationIds,
   supportedOperationIds,
@@ -5362,4 +5501,4 @@ export {
   scanResults,
   PrismAPI
 };
-//# sourceMappingURL=chunk-OZBUWLPY.js.map
+//# sourceMappingURL=chunk-EJSDM62Y.js.map