@crvouga/mockingbird-service-junction 0.5.0 → 0.7.0

package/dist/{chunk-ICINEQ7D.js → chunk-MS774AJA.js}

@@ -247,20 +247,66 @@ var createControlPlane = (context) => {
       return context.faults.remove(id) ? json(200, { status: "ok" }) : adminError(404, `no fault ${id}`);
     },
     "POST /snapshots": ({ namespace }) => {
-      const snapshot = context.snapshot(namespace);
+      const point = context.timeTravel.checkpoint(namespace, "main");
+      context.timeTravel.retain(namespace, point.id);
       snapshotCounter++;
       const id = `snap_${snapshotCounter}`;
-      snapshots.set(id, snapshot);
-      return json(201, { id, namespace, records: snapshot.records.length });
+      snapshots.set(id, { namespace, checkpoint: point.id });
+      return json(201, { id, namespace, records: point.records ?? 0 });
     },
     "POST /snapshots/:id/restore": ({ params, namespace }) => {
-      const snapshot = snapshots.get(params.id);
-      if (!snapshot)
+      const alias = snapshots.get(params.id);
+      if (!alias)
         return adminError(404, `no snapshot ${params.id}`);
-      context.restore(namespace, snapshot);
+      if (alias.namespace !== namespace) {
+        return adminError(409, `snapshot ${params.id} belongs to namespace ${alias.namespace}`);
+      }
+      context.timeTravel.checkout(alias.checkpoint, { namespace, branch: "main" });
       return json(200, { status: "ok", id: params.id, namespace });
     },
-    "DELETE /snapshots/:id": ({ params }) => snapshots.delete(params.id) ? json(200, { status: "ok" }) : adminError(404, `no snapshot ${params.id}`),
+    "DELETE /snapshots/:id": ({ params }) => {
+      const id = params.id;
+      const alias = snapshots.get(id);
+      if (!alias)
+        return adminError(404, `no snapshot ${id}`);
+      snapshots.delete(id);
+      context.timeTravel.release(alias.namespace, alias.checkpoint);
+      return json(200, { status: "ok" });
+    },
+    "GET /timeline": ({ namespace }) => json(200, context.timeTravel.inspect(namespace)),
+    "POST /checkpoints": ({ body, namespace }) => {
+      const branch = isRecord(body) && typeof body.branch === "string" ? body.branch : "main";
+      try {
+        return json(201, context.timeTravel.checkpoint(namespace, branch));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name": ({ params, body, namespace }) => {
+      const at = isRecord(body) && typeof body.at === "string" ? body.at : void 0;
+      try {
+        return json(201, context.timeTravel.branch(params.name, {
+          namespace,
+          ...at !== void 0 ? { at } : {}
+        }));
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
+    "POST /branches/:name/checkout": ({ params, body, namespace }) => {
+      if (!isRecord(body) || typeof body.checkpoint !== "string") {
+        return adminError(400, 'expected {"checkpoint":"cp_..."}');
+      }
+      try {
+        context.timeTravel.checkout(body.checkpoint, {
+          namespace,
+          branch: params.name
+        });
+        return json(200, { status: "ok", branch: params.name, checkpoint: body.checkpoint });
+      } catch (error) {
+        return adminError(409, error instanceof Error ? error.message : String(error));
+      }
+    },
     "GET /requests": ({ url, namespace }) => {
       const status = url.searchParams.get("status");
       const since = url.searchParams.get("since");
@@ -308,7 +354,7 @@ var createControlPlane = (context) => {
         return json(200, {
           status: "ok",
           service: context.name,
-          uptimeMs: Date.now() - context.startedAt,
+          uptimeMs: context.wallNow() - context.startedAt,
           clock: context.clock.state(),
           namespaces: context.namespaces().length,
           ...context.describe()
@@ -386,6 +432,13 @@ var createRng = (seed = 0) => {
     reset: () => {
       state = numeric;
     },
+    state: () => state,
+    setState: (next2) => {
+      if (!Number.isSafeInteger(next2) || next2 < 0 || next2 > 4294967295) {
+        throw new RangeError("rng state must be an unsigned 32-bit integer");
+      }
+      state = next2 >>> 0;
+    },
     seed: numeric
   };
 };
@@ -414,7 +467,7 @@ var faultResponse = (rule) => {
   const body = rule.body === void 0 ? { detail: "Injected by Mockingbird" } : rule.body;
   return new Response(JSON.stringify(body), { status, headers });
 };
-var createFaultRegistry = (rng = createRng(0)) => {
+var createFaultRegistry = (rng = createRng(0), sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) => {
   const entries = [];
   return {
     add(rule) {
@@ -452,7 +505,7 @@ var createFaultRegistry = (rng = createRng(0)) => {
           entry.remaining--;
         const delay = entry.rule.delayMs ?? entry.rule.latencyMs;
         if (delay !== void 0 && delay > 0) {
-          await new Promise((resolve) => setTimeout(resolve, delay));
+          await sleep(delay);
         }
         const hit = { id: entry.rule.id };
         if (entry.rule.effect !== void 0) {
@@ -861,6 +914,167 @@ var createMetrics = () => {
   };
 };
 
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
 // ../../sqlite/dist/default.js
 import { Database } from "@crvouga/mockingbird-service-sqlite";
 var createDefaultSqlite = () => new Database();
@@ -1082,7 +1296,7 @@ var restoreNamespace = (sqlite, namespace, snapshot) => {
 };
 
 // ../core/dist/version.js
-var PACKAGE_VERSION = true ? "0.5.0" : UNRELEASED_VERSION;
+var PACKAGE_VERSION = true ? "0.7.0" : UNRELEASED_VERSION;
 
 // ../core/dist/webhooks.js
 var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
@@ -1188,10 +1402,33 @@ var parsePayload = (message) => {
 
 // ../core/dist/runtime.js
 var MOCKINGBIRD_HEADER = "x-mockingbird";
+var BRANCH_HEADER = "x-mockingbird-branch";
+var AT_HEADER = "x-mockingbird-at";
+var CHECKPOINT_HEADER = "x-mockingbird-checkpoint";
 var DEFAULT_NAMESPACE = "default";
 var NAMESPACE_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
 var PATH_PREFIX = /^\/ns\/([^/]+)(\/.*)?$/;
+var BRANCH_PATTERN2 = /^[A-Za-z0-9_.-]{1,64}$/;
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 var effects = /* @__PURE__ */ new WeakMap();
+var reuseSorted = (fresh, previous, compare, equal) => {
+  if (!previous || previous.length === 0)
+    return fresh.map((row) => Object.freeze(row));
+  const result = new Array(fresh.length);
+  let unchanged = fresh.length === previous.length;
+  let oldIndex = 0;
+  for (let index = 0; index < fresh.length; index++) {
+    const row = fresh[index];
+    while (oldIndex < previous.length && compare(previous[oldIndex], row) < 0) {
+      oldIndex++;
+    }
+    const old = previous[oldIndex];
+    result[index] = old !== void 0 && compare(old, row) === 0 && equal(old, row) ? old : Object.freeze(row);
+    if (result[index] !== previous[index])
+      unchanged = false;
+  }
+  return unchanged ? previous : result;
+};
 var DroppedConnectionError = class extends TypeError {
   code = "MOCKINGBIRD_DROP";
   constructor() {
@@ -1212,36 +1449,173 @@ var createRuntime = (options) => {
   const sqlite = bootSqlite(options.sqlite);
   const clock = options.clock ?? createClock();
   const rng = createRng(options.seed ?? 0);
-  const faults = createFaultRegistry(createRng(options.seed ?? 0));
+  const wallNow = options.io?.wallNow ?? Date.now;
+  const monotonicNow = options.io?.monotonicNow ?? (() => performance.now());
+  const sleep = options.io?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const faults = createFaultRegistry(createRng(options.seed ?? 0), sleep);
   const metrics = createMetrics();
   const journal = createJournal(options.journalSize ?? DEFAULT_JOURNAL_SIZE);
   const version = options.version ?? PACKAGE_VERSION;
   const instances = /* @__PURE__ */ new Map();
+  const publicNamespaces = /* @__PURE__ */ new Set();
+  const branchRngs = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const branchStorage = /* @__PURE__ */ new Map();
+  const captured = /* @__PURE__ */ new Map();
   const credentials = createCredentialRegistry();
   const operationIdFor = options.document ? operationMatcher(options.document) : () => void 0;
   const storageNamespace = (name) => name === DEFAULT_NAMESPACE ? options.name : `${options.name}:${name}`;
-  const instance = (name = DEFAULT_NAMESPACE) => {
-    const existing = instances.get(name);
+  const instanceFor = (key, publicNamespace = key, isolatedRng) => {
+    const existing = instances.get(key);
     if (existing)
       return existing;
-    if (!NAMESPACE_PATTERN.test(name)) {
-      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(name)}`);
+    if (!NAMESPACE_PATTERN.test(key) || !NAMESPACE_PATTERN.test(publicNamespace)) {
+      throw new RangeError(`namespace must match ${NAMESPACE_PATTERN}: ${JSON.stringify(publicNamespace)}`);
     }
     const created = options.create({
-      namespace: storageNamespace(name),
-      publicNamespace: name,
+      namespace: storageNamespace(key),
+      publicNamespace,
       sqlite,
       clock,
-      rng
+      rng: isolatedRng ?? rng
     });
-    instances.set(name, created);
+    instances.set(key, created);
+    publicNamespaces.add(publicNamespace);
+    if (isolatedRng)
+      branchRngs.set(key, isolatedRng);
     return created;
   };
+  const instance = (name = DEFAULT_NAMESPACE) => instanceFor(name);
+  const capture = (storage) => {
+    const fresh = snapshotNamespace(sqlite, storageNamespace(storage));
+    const previous = captured.get(storage);
+    const snapshot2 = {
+      namespace: fresh.namespace,
+      records: reuseSorted(fresh.records, previous?.records, (left, right) => left.collection < right.collection ? -1 : left.collection > right.collection ? 1 : left.seq - right.seq, (left, right) => left.id === right.id && left.value === right.value),
+      sequences: reuseSorted(fresh.sequences, previous?.sequences, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : left.kind < right.kind ? -1 : left.kind > right.kind ? 1 : 0, (left, right) => left.value === right.value)
+    };
+    Object.freeze(snapshot2.records);
+    Object.freeze(snapshot2.sequences);
+    Object.freeze(snapshot2);
+    captured.set(storage, snapshot2);
+    return Object.freeze({
+      snapshot: snapshot2,
+      clock: Object.freeze(clock.state()),
+      rngState: (branchRngs.get(storage) ?? rng).state()
+    });
+  };
+  const timeline = (name = DEFAULT_NAMESPACE) => {
+    let found = timelines.get(name);
+    if (found)
+      return found;
+    instance(name);
+    found = new Timeline({
+      now: clock.now,
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    found.commit(capture(name));
+    timelines.set(name, found);
+    return found;
+  };
+  const physicalBranch = (namespace, branch2) => {
+    if (branch2 === "main")
+      return namespace;
+    const mapKey = `${namespace}\0${branch2}`;
+    const existing = branchStorage.get(mapKey);
+    if (existing)
+      return existing;
+    const key = `branch_${seedFrom(`${options.name}\0${namespace}\0${branch2}`).toString(36)}`;
+    branchStorage.set(mapKey, key);
+    return key;
+  };
+  const ensureBranch = (namespace, branch2, at) => {
+    if (!BRANCH_PATTERN2.test(branch2))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN2}`);
+    const history = timeline(namespace);
+    if (branch2 === "main") {
+      if (at !== void 0) {
+        const point = history.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);
+        if (point.value.clock.frozen)
+          clock.freeze();
+        else
+          clock.unfreeze();
+      }
+      return namespace;
+    }
+    const storage = physicalBranch(namespace, branch2);
+    if (!history.hasBranch(branch2)) {
+      if (at === void 0)
+        history.commit(capture(namespace));
+      const point = history.fork(branch2, at === void 0 ? {} : { from: at });
+      const branchRng = createRng(options.seed ?? 0);
+      if (point)
+        branchRng.setState(point.value.rngState);
+      instanceFor(storage, namespace, branchRng);
+      if (point)
+        restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      if (point)
+        captured.set(storage, point.value.snapshot);
+    } else if (at !== void 0 && history.head(branch2)?.id !== at) {
+      const point = history.checkout(branch2, at);
+      if (!instances.has(storage)) {
+        const branchRng = createRng(options.seed ?? 0);
+        branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+      branchRngs.get(storage)?.setState(point.value.rngState);
+      restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+      captured.set(storage, point.value.snapshot);
+    } else {
+      if (!instances.has(storage)) {
+        const point = history.head(branch2);
+        const branchRng = createRng(options.seed ?? 0);
+        if (point)
+          branchRng.setState(point.value.rngState);
+        instanceFor(storage, namespace, branchRng);
+      }
+    }
+    return storage;
+  };
+  const checkpoint = (namespace = DEFAULT_NAMESPACE, branch2 = "main") => {
+    const storage = ensureBranch(namespace, branch2);
+    return timeline(namespace).commit(capture(storage), { branch: branch2 });
+  };
+  const branch = (name, branchOptions = {}) => {
+    const namespace = branchOptions.namespace ?? DEFAULT_NAMESPACE;
+    ensureBranch(namespace, name, branchOptions.at);
+    const head = timeline(namespace).head(name);
+    if (!head)
+      throw new RangeError(`branch ${name} has no checkpoint`);
+    return head;
+  };
+  const checkout = (checkpointId, checkoutOptions = {}) => {
+    const namespace = checkoutOptions.namespace ?? DEFAULT_NAMESPACE;
+    const branchName = checkoutOptions.branch ?? "main";
+    const history = timeline(namespace);
+    const point = history.checkout(branchName, checkpointId);
+    const storage = ensureBranch(namespace, branchName);
+    restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+    captured.set(storage, point.value.snapshot);
+    clock.set(point.value.clock.now);
+    if (point.value.clock.frozen)
+      clock.freeze();
+    else
+      clock.unfreeze();
+    (branchRngs.get(storage) ?? rng).setState(point.value.rngState);
+  };
   const reset = async (name = DEFAULT_NAMESPACE) => {
     if (name === "*") {
       options.webhooks?.clear();
       for (const each of instances.values())
         await each.reset();
+      timelines.clear();
+      branchStorage.clear();
+      branchRngs.clear();
+      captured.clear();
       return;
     }
     options.webhooks?.clear(name);
@@ -1250,14 +1624,33 @@ var createRuntime = (options) => {
       await target.reset();
     else
       clearNamespace(sqlite, storageNamespace(name));
+    for (const [mapping, storage] of branchStorage) {
+      if (!mapping.startsWith(`${name}\0`))
+        continue;
+      const branchInstance = instances.get(storage);
+      if (branchInstance)
+        await branchInstance.reset();
+      else
+        clearNamespace(sqlite, storageNamespace(storage));
+      branchStorage.delete(mapping);
+      branchRngs.delete(storage);
+      captured.delete(storage);
+    }
+    timelines.delete(name);
+    captured.delete(name);
   };
   const snapshot = (name = DEFAULT_NAMESPACE) => {
-    instance(name);
-    return snapshotNamespace(sqlite, storageNamespace(name));
+    return checkpoint(name, "main").value.snapshot;
   };
   const restore = (from, name = DEFAULT_NAMESPACE) => {
     instance(name);
     restoreNamespace(sqlite, storageNamespace(name), from);
+    captured.set(name, from);
+    const history = timelines.get(name);
+    if (history)
+      history.commit(capture(name), { branch: "main" });
+    else
+      timeline(name);
   };
   const runtime = {
     name: options.name,
@@ -1289,10 +1682,14 @@ var createRuntime = (options) => {
       return added;
     },
     instance,
-    namespaces: () => [...instances.keys()].sort(),
+    namespaces: () => [...publicNamespaces].sort(),
     reset,
     snapshot,
     restore,
+    checkpoint,
+    branch,
+    checkout,
+    timeline,
     fetch: async (incoming) => {
       let request2 = incoming;
       const prefixed = PATH_PREFIX.exec(new URL(request2.url).pathname);
@@ -1318,6 +1715,8 @@ var createRuntime = (options) => {
         if (mapped !== void 0)
           namespace = mapped;
       }
+      const selectedBranch = request2.headers.get(BRANCH_HEADER) ?? "main";
+      const at = request2.headers.get(AT_HEADER) ?? void 0;
       const stamp = (response2) => {
         const value = NAMESPACE_PATTERN.test(namespace) ? `${options.name}@${version}; ns=${namespace}` : `${options.name}@${version}`;
         try {
@@ -1332,7 +1731,7 @@ var createRuntime = (options) => {
       const handled = await control.handle(request2);
       if (handled)
         return stamp(handled);
-      const started = performance.now();
+      const started = monotonicNow();
       const url = new URL(request2.url);
       const operationId = operationIdFor(request2, url.pathname);
       const log = (status, faultId, response2) => {
@@ -1344,7 +1743,7 @@ var createRuntime = (options) => {
           method: request2.method,
           path: url.pathname,
           status,
-          durationMs: Math.round((performance.now() - started) * 100) / 100,
+          durationMs: Math.round((monotonicNow() - started) * 100) / 100,
           unmatched: options.document !== void 0 && operationId === void 0,
           ...faultId !== void 0 ? { faultId } : {},
           ...noted?.ids && Object.keys(noted.ids).length > 0 ? { ids: noted.ids } : {},
@@ -1363,6 +1762,30 @@ var createRuntime = (options) => {
           }
         }), { status: 400, headers: { "content-type": "application/json" } }));
       }
+      if (!BRANCH_PATTERN2.test(selectedBranch)) {
+        log(400);
+        return stamp(adminFail(400, `${BRANCH_HEADER} must match ${BRANCH_PATTERN2}`));
+      }
+      let storage;
+      try {
+        if (at !== void 0 && selectedBranch === "main" && !MUTATING_METHODS.has(request2.method)) {
+          const point = timeline(namespace).get(at);
+          storage = physicalBranch(namespace, `at_${at}`);
+          let viewRng = branchRngs.get(storage);
+          if (!viewRng) {
+            viewRng = createRng(options.seed ?? 0);
+            instanceFor(storage, namespace, viewRng);
+          }
+          viewRng.setState(point.value.rngState);
+          restoreNamespace(sqlite, storageNamespace(storage), point.value.snapshot);
+          captured.set(storage, point.value.snapshot);
+        } else {
+          storage = ensureBranch(namespace, selectedBranch, at);
+        }
+      } catch (error) {
+        log(409);
+        return stamp(adminFail(409, error instanceof Error ? error.message : String(error)));
+      }
       const hits = await faults.take({
         operationId,
         method: request2.method,
@@ -1381,14 +1804,28 @@ var createRuntime = (options) => {
       const fired = hits.filter((hit) => hit.effect !== void 0);
       if (fired.length > 0)
         effects.set(request2, fired.map((hit) => hit.effect));
-      const response = await instance(namespace).fetch(request2);
+      let response = await instanceFor(storage, namespace).fetch(request2);
+      if (MUTATING_METHODS.has(request2.method) && response.status >= 200 && response.status < 400) {
+        const point = timeline(namespace).commit(capture(storage), { branch: selectedBranch });
+        response = mutableResponse(response);
+        response.headers.set(CHECKPOINT_HEADER, point.id);
+      }
+      if (selectedBranch !== "main") {
+        response = mutableResponse(response);
+        response.headers.set(BRANCH_HEADER, selectedBranch);
+      }
+      if (at !== void 0) {
+        response = mutableResponse(response);
+        response.headers.set(AT_HEADER, at);
+      }
       log(response.status, fired[0]?.id, response);
       return stamp(response);
     }
   };
   const control = createControlPlane({
     name: options.name,
-    startedAt: Date.now(),
+    startedAt: wallNow(),
+    wallNow,
     clock,
     faults,
     metrics,
@@ -1396,8 +1833,39 @@ var createRuntime = (options) => {
     defaultNamespace: DEFAULT_NAMESPACE,
     namespaces: runtime.namespaces,
     reset,
-    snapshot: (name) => snapshot(name),
-    restore: (name, from) => restore(from, name),
+    timeTravel: {
+      checkpoint: (name, branchName) => {
+        const point = checkpoint(name, branchName);
+        return {
+          id: point.id,
+          branch: point.branch,
+          parent: point.parent,
+          at: point.at,
+          records: point.value.snapshot.records.length
+        };
+      },
+      branch: (branchName, branchOptions) => {
+        const point = branch(branchName, branchOptions);
+        return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+      },
+      checkout: (checkpointId, checkoutOptions) => checkout(checkpointId, checkoutOptions),
+      retain: (name, checkpointId) => {
+        timeline(name).retain(checkpointId);
+      },
+      release: (name, checkpointId) => timeline(name).release(checkpointId),
+      inspect: (name) => {
+        const history = timeline(name);
+        return {
+          branches: history.branches(),
+          checkpoints: history.checkpoints().map(({ id, branch: branchName, parent, at }) => ({
+            id,
+            branch: branchName,
+            parent,
+            at
+          }))
+        };
+      }
+    },
     describe: options.describe ?? (() => ({})),
     ...options.presets ? {
       applyPreset: (name, namespace, overrides) => runtime.applyPreset(name, namespace, overrides)
@@ -1412,6 +1880,15 @@ var createRuntime = (options) => {
   });
   return runtime;
 };
+var mutableResponse = (response) => {
+  try {
+    response.headers.set("x-mockingbird-mutable-probe", "1");
+    response.headers.delete("x-mockingbird-mutable-probe");
+    return response;
+  } catch {
+    return new Response(response.body, response);
+  }
+};
 var adminJson = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
 var adminFail = (status, message) => adminJson(status, { error: { type: "mockingbird_admin", message } });
 var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4346,7 +4823,7 @@ var linkAppointmentToOrder = (state, order, appointment, status, nowIso) => {
     transactionOrder.updated_at = nowIso;
   }
   state.orders.update(order.id, order);
-  state.publishOrderWebhook(order, "labtest.order.updated");
+  state.publishOrderWebhook(order, "labtest.order.updated", new Date(nowIso).getTime());
 };
 var appendAppointmentEvent = (appointment, status, at) => {
   const event = { created_at: at, status, data: null };
@@ -5192,7 +5669,7 @@ var pyIso = (value) => {
   const ms = (match?.[1] ?? "000").padEnd(6, "0");
   return `${date}T${time.slice(0, 8)}.${ms}+00:00`;
 };
-var orderValidation = (body) => {
+var orderValidation = (body, now = Date.now) => {
   const errors = [];
   const userId = body.user_id;
   if (userId === void 0) errors.push(missingError(["body", "user_id"], body));
@@ -5290,7 +5767,7 @@ var orderValidation = (body) => {
         const emailError = userEmailError(p[field]);
         if (emailError) errors.push(emailError);
       } else if (field === "dob") {
-        const dobError = orderDobError(p[field]);
+        const dobError = orderDobError(p[field], now());
         if (dobError) errors.push(dobError);
       } else if (field === "phone_number" && !isValidPhone(p[field])) {
         errors.push(phoneError(["body", "patient_details", "phone_number"], p[field]));
@@ -5338,11 +5815,11 @@ var userEmailError = (value) => {
   }
   return void 0;
 };
-var orderDobError = (dob) => {
+var orderDobError = (dob, nowMs) => {
   if (/^\d{4}-\d{2}-\d{2}T/.test(dob)) {
     if (/^\d{4}-\d{2}-\d{2}T00:00:00/.test(dob)) {
       const dateOnly = dob.slice(0, 10);
-      if ((/* @__PURE__ */ new Date(`${dateOnly}T00:00:00Z`)).getTime() > Date.now()) {
+      if ((/* @__PURE__ */ new Date(`${dateOnly}T00:00:00Z`)).getTime() > nowMs) {
         return {
           type: "value_error",
           loc: ["body", "patient_details", "dob"],
@@ -5383,7 +5860,7 @@ var orderDobError = (dob) => {
         ctx: { error: {} }
       };
     }
-    if ((/* @__PURE__ */ new Date(`${dob}T00:00:00Z`)).getTime() > Date.now()) {
+    if ((/* @__PURE__ */ new Date(`${dob}T00:00:00Z`)).getTime() > nowMs) {
       return {
         type: "value_error",
         loc: ["body", "patient_details", "dob"],
@@ -5615,7 +6092,7 @@ var orderHandlers = (state) => ({
         });
       }
     }
-    const errors = orderValidation(body);
+    const errors = orderValidation(body, context.now);
     if (errors.length > 0) throw new HttpError(422, { detail: errors });
     const rawAddress = body.patient_address;
     if (typeof rawAddress === "object" && rawAddress !== null && !Array.isArray(rawAddress) && typeof rawAddress.country === "string" && /[^A-Za-z ]/.test(rawAddress.country ?? "")) {
@@ -8145,14 +8622,17 @@ var createWebhookDispatcher = (endpoint) => {
   const delays = endpoint.retryDelaysMs ?? WEBHOOK_RETRY_DELAYS_MS;
   const timeoutMs = endpoint.timeoutMs ?? 15e3;
   const send = endpoint.fetch ?? ((request2) => fetch(request2));
+  const now = endpoint.now ?? Date.now;
+  const scheduleTimer = endpoint.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const cancel = endpoint.cancel ?? ((handle) => clearTimeout(handle));
   const deliveries = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Set();
   let sequence = 0;
   const attempt = async (delivery) => {
     const body = JSON.stringify(delivery.event);
-    const timestamp = Math.floor(Date.now() / 1e3);
-    const started = Date.now();
+    const timestamp = Math.floor(now() / 1e3);
+    const started = now();
     const record = {
       attempt: delivery.attempts.length + 1,
       at: new Date(started).toISOString(),
@@ -8161,7 +8641,7 @@ var createWebhookDispatcher = (endpoint) => {
       durationMs: 0
     };
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timer = scheduleTimer(() => controller.abort(), timeoutMs);
     try {
       const response = await send(
         new Request(endpoint.url, {
@@ -8182,8 +8662,8 @@ var createWebhookDispatcher = (endpoint) => {
     } catch (error) {
       record.error = controller.signal.aborted ? `timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
     } finally {
-      clearTimeout(timer);
-      record.durationMs = Date.now() - started;
+      cancel(timer);
+      record.durationMs = now() - started;
       delivery.attempts.push(record);
     }
     return record.status !== null && record.status >= 200 && record.status < 300;
@@ -8213,7 +8693,7 @@ var createWebhookDispatcher = (endpoint) => {
       run();
       return;
     }
-    const timer = setTimeout(run, delay);
+    const timer = scheduleTimer(run, delay);
     unref(timer);
     pending.set(delivery.messageId, { delivery, timer });
   };
@@ -8236,7 +8716,7 @@ var createWebhookDispatcher = (endpoint) => {
       const delivery = deliveries.get(messageId);
       if (!delivery) return void 0;
       const queued = pending.get(messageId);
-      if (queued?.timer !== void 0) clearTimeout(queued.timer);
+      if (queued?.timer !== void 0) cancel(queued.timer);
       pending.delete(messageId);
       const ok = await attempt(delivery);
       delivery.state = ok ? "delivered" : "failed";
@@ -8244,7 +8724,7 @@ var createWebhookDispatcher = (endpoint) => {
     },
     async flush() {
       for (const [id, queued] of [...pending]) {
-        if (queued.timer !== void 0) clearTimeout(queued.timer);
+        if (queued.timer !== void 0) cancel(queued.timer);
         pending.delete(id);
         track(
           attempt(queued.delivery).then((ok) => {
@@ -8262,7 +8742,7 @@ var createWebhookDispatcher = (endpoint) => {
       for (const [id, delivery] of [...deliveries]) {
         if (namespace !== void 0 && delivery.namespace !== namespace) continue;
         const queued = pending.get(id);
-        if (queued?.timer !== void 0) clearTimeout(queued.timer);
+        if (queued?.timer !== void 0) cancel(queued.timer);
         pending.delete(id);
         deliveries.delete(id);
       }
@@ -9128,4 +9608,4 @@ export {
   JunctionAPI,
   LabAccountConflict
 };
-//# sourceMappingURL=chunk-ICINEQ7D.js.map
+//# sourceMappingURL=chunk-MS774AJA.js.map