on-zero 0.7.10 → 0.8.0

package/dist/cjs/helpers/getCurrentComponentStack.cjs

@@ -0,0 +1,71 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getCurrentComponentStack_exports = {};
+__export(getCurrentComponentStack_exports, {
+  getCurrentComponentStack: () => getCurrentComponentStack
+});
+module.exports = __toCommonJS(getCurrentComponentStack_exports);
+var import_react = __toESM(require("react"), 1);
+const getCurrentComponentStack = format => {
+  if (process.env.NODE_ENV === "development") {
+    const captureOwnerStack = import_react.default.captureOwnerStack;
+    const stack = typeof captureOwnerStack === "function" ? captureOwnerStack() : null;
+    if (!stack) return "";
+    if (format === "short") {
+      return formatStackToShort(stack);
+    }
+    return stack;
+  }
+  return `(prod, no stack)`;
+};
+const formatStackToShort = stack => {
+  if (process.env.NODE_ENV === "development") {
+    const lines = stack.slice(0, 6e3).split("\n");
+    const componentNames = [];
+    for (const line of lines) {
+      const match = line.match(/\s*at\s+([A-Z][a-zA-Z0-9_]*)\s*\(/);
+      if (match) {
+        const componentName = match[1];
+        if (componentName && componentName !== "Array" && componentName !== "Root" && componentName !== "Route") {
+          componentNames.push(componentName);
+          if (componentNames.length > 10) {
+            break;
+          }
+        }
+      }
+    }
+    return componentNames.join(" < ");
+  }
+  return stack;
+};

package/dist/cjs/helpers/getCurrentComponentStack.native.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var getCurrentComponentStack_exports = {};
+__export(getCurrentComponentStack_exports, {
+  getCurrentComponentStack: () => getCurrentComponentStack
+});
+module.exports = __toCommonJS(getCurrentComponentStack_exports);
+var import_react = __toESM(require("react"), 1);
+var getCurrentComponentStack = function getCurrentComponentStack2(format) {
+  if (process.env.NODE_ENV === "development") {
+    var captureOwnerStack = import_react.default.captureOwnerStack;
+    var stack = typeof captureOwnerStack === "function" ? captureOwnerStack() : null;
+    if (!stack) return "";
+    if (format === "short") {
+      return formatStackToShort(stack);
+    }
+    return stack;
+  }
+  return `(prod, no stack)`;
+};
+var formatStackToShort = function formatStackToShort2(stack) {
+  if (process.env.NODE_ENV === "development") {
+    var lines = stack.slice(0, 6e3).split("\n");
+    var componentNames = [];
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var line = _step.value;
+        var match = line.match(/\s*at\s+([A-Z][a-zA-Z0-9_]*)\s*\(/);
+        if (match) {
+          var componentName = match[1];
+          if (componentName && componentName !== "Array" && componentName !== "Root" && componentName !== "Route") {
+            componentNames.push(componentName);
+            if (componentNames.length > 10) {
+              break;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return componentNames.join(" < ");
+  }
+  return stack;
+};
+//# sourceMappingURL=getCurrentComponentStack.native.js.map

package/dist/cjs/helpers/getCurrentComponentStack.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","getCurrentComponentStack_exports","__export","getCurrentComponentStack","module","exports","import_react","__toESM","require","getCurrentComponentStack2","format","process","env","NODE_ENV","captureOwnerStack","default","stack","formatStackToShort","formatStackToShort2","lines","slice","split","componentNames","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","Symbol","iterator","_step","next","done","line","match","componentName","push","length"],"sources":["../../../src/helpers/getCurrentComponentStack.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,gCAAA;AAAAC,QAAA,CAAAD,gCAAA;EAAAE,wBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAkB,CAAAK,gCAAA;AAEX,IAAAK,YAAM,GAAAC,OAAA,CAAAC,OAA4B,WAA6B;AACpE,IAAAL,wBAAgB,GAAa,SAAAM,yBAAeA,CAAAC,MAAA;EAE1C,IAAAC,OAAM,CAAAC,GAAA,CAAAC,QAAA,KAAqB;IAC3B,IAAAC,iBAAqB,GAAAR,YAAA,CAAAS,OAAsB,CAAAD,iBAAa;IAExD,IAAIE,KAAC,GAAO,OAAOF,iBAAA,kBAAAA,iBAAA;IAEnB,IAAI,CAAAE,KAAA,SAAW;IACb,IAAAN,MAAO;MACT,OAAAO,kBAAA,CAAAD,KAAA;IAEA;IACF,OAAAA,KAAA;EAEA;EACF;AAEA;AACE,IAAAC,kBAAgB,YAAaC,mBAAeA,CAAAF,KAAA;EAC1C,IAAAL,OAAM,CAAAC,GAAA,CAAQC,QAEX,KAAM,aACA;IAET,IAAAM,KAAM,GAAAH,KAAA,CAAAI,KAA2B,CAAC,QAAAC,KAAA;IAElC,IAAAC,cAAW,GAAQ;IAGjB,IAAAC,yBAAyB;MAAAC,iBAAA,QAAmC;MAAAC,cAAA;IAC5D;MACE,SAAMC,SAAA,GAAAP,KAAgB,CAAAQ,MAAO,CAAAC,QAAA,KAAAC,KAAA,IAAAN,yBAAA,IAAAM,KAAA,GAAAH,SAAA,CAAAI,IAAA,IAAAC,IAAA,GAAAR,yBAAA;QAE7B,IACES,IAAA,GAAAH,KAAA,CAAA7B,KACA;QAIA,IAAAiC,KAAA,GAAAD,IAAA,CAAeC,KAAK,oCAAa;QACjC,IAAAA,KAAI;UAEF,IAAAC,aAAA,GAAAD,KAAA;UACF,IAAAC,aAAA,IAAAA,aAAA,gBAAAA,aAAA,eAAAA,aAAA;YACFZ,cAAA,CAAAa,IAAA,CAAAD,aAAA;YACF,IAAAZ,cAAA,CAAAc,MAAA;cACF;YAEO;UACT;QAEA;MACF","ignoreList":[]}

package/dist/cjs/helpers/globalValue.cjs

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var globalValue_exports = {};
+__export(globalValue_exports, {
+  globalValue: () => globalValue
+});
+module.exports = __toCommonJS(globalValue_exports);
+function globalValue(key, factory, opts) {
+  const symbolKey = Symbol.for(key);
+  const g = globalThis;
+  if (!g[symbolKey]) {
+    g[symbolKey] = factory();
+  } else {
+    if (opts?.warnMessage) {
+      console.warn(`[globalValue] ${opts.warnMessage}`);
+    }
+  }
+  return g[symbolKey];
+}

package/dist/cjs/helpers/globalValue.native.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var globalValue_exports = {};
+__export(globalValue_exports, {
+  globalValue: () => globalValue
+});
+module.exports = __toCommonJS(globalValue_exports);
+function globalValue(key, factory, opts) {
+  var symbolKey = Symbol.for(key);
+  var g = globalThis;
+  if (!g[symbolKey]) {
+    g[symbolKey] = factory();
+  } else {
+    if (opts === null || opts === void 0 ? void 0 : opts.warnMessage) {
+      console.warn(`[globalValue] ${opts.warnMessage}`);
+    }
+  }
+  return g[symbolKey];
+}
+//# sourceMappingURL=globalValue.native.js.map

package/dist/cjs/helpers/globalValue.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","globalValue_exports","__export","globalValue","module","exports","key","factory","opts","symbolKey","Symbol","for","g","globalThis","warnMessage","console","warn"],"sources":["../../../src/helpers/globalValue.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,mBAAA;AAAAC,QAAA,CAAAD,mBAAA;EAAAE,WAAA,EAAAA,CAAA,KAAAA;AAAA;AAoBOC,MAAA,CAAAC,OAAS,GAAAT,YAEd,CAAAK,mBAIG;AACH,SAAME,WAAYA,CAAAG,GAAA,EAAAC,OAAW,EAAGC,IAAA;EAChC,IAAAC,SAAU,GAAAC,MAAA,CAAAC,GAAA,CAAAL,GAAA;EAEV,IAAIM,CAAC,GAAEC,UAAS;EACd,IAAE,CAAAD,CAAA,CAAAH,SAAS,CAAI;IACjBG,CAAA,CAAAH,SAAO,IAAAF,OAAA;EACL,OAAI;IACF,IAAAC,IAAA,KAAQ,IAAK,IAAAA,IAAA,UAAiB,IAAK,SAAWA,IAAE,CAAAM,WAAA;MAClDC,OAAA,CAAAC,IAAA,kBAAAR,IAAA,CAAAM,WAAA;IACF;EAEA;EACF,OAAAF,CAAA,CAAAH,SAAA","ignoreList":[]}

package/dist/cjs/helpers/mapObject.cjs

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var mapObject_exports = {};
+__export(mapObject_exports, {
+  mapObject: () => mapObject
+});
+module.exports = __toCommonJS(mapObject_exports);
+function mapObject(obj, fn) {
+  const result = {};
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      result[key] = fn(obj[key], key);
+    }
+  }
+  return result;
+}

package/dist/cjs/helpers/mapObject.native.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var mapObject_exports = {};
+__export(mapObject_exports, {
+  mapObject: () => mapObject
+});
+module.exports = __toCommonJS(mapObject_exports);
+function mapObject(obj, fn) {
+  var result = {};
+  for (var key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      result[key] = fn(obj[key], key);
+    }
+  }
+  return result;
+}
+//# sourceMappingURL=mapObject.native.js.map

package/dist/cjs/helpers/mapObject.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","mapObject_exports","__export","mapObject","module","exports","obj","fn","result","key","Object","hasOwn"],"sources":["../../../src/helpers/mapObject.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,iBAAA;AAAAC,QAAA,CAAAD,iBAAA;EAAAE,SAAA,EAAAA,CAAA,KAAAA;AAAA;AAAOC,MAAA,CAAAC,OAAS,GAAAT,YAGS,CAAAK,iBAAA;AACvB,SAAME,SAAUA,CAAAG,GAAA,EAAAC,EAAA;EAEhB,IAAAC,MAAA,GAAW;EACT,SAAIC,GAAA,IAAOH,GAAA,EAAO;IAChB,IAAAI,MAAO,CAAAC,MAAO,CAAAL,GAAG,EAAIG,GAAG,GAAG;MAC7BD,MAAA,CAAAC,GAAA,IAAAF,EAAA,CAAAD,GAAA,CAAAG,GAAA,GAAAA,GAAA;IACF;EAEA;EACF,OAAAD,MAAA","ignoreList":[]}

package/dist/cjs/helpers/mutationLifecycle.cjs

@@ -0,0 +1,251 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var mutationLifecycle_exports = {};
+__export(mutationLifecycle_exports, {
+  MutationResultError: () => MutationResultError,
+  MutationTimeoutError: () => MutationTimeoutError,
+  StaleGenerationError: () => StaleGenerationError,
+  createMutationLifecycle: () => createMutationLifecycle,
+  isStaleGenerationError: () => isStaleGenerationError,
+  mutationErrorMessage: () => mutationErrorMessage
+});
+module.exports = __toCommonJS(mutationLifecycle_exports);
+class StaleGenerationError extends Error {
+  label;
+  constructor(label) {
+    super(`${label} stopped because its Zero instance was replaced or recovered`);
+    this.name = "StaleGenerationError";
+    this.label = label;
+  }
+}
+class MutationTimeoutError extends Error {
+  label;
+  phase;
+  timeoutMs;
+  constructor(label, phase, timeoutMs) {
+    super(phase === "server" ? `${label} server acknowledgement did not complete within ${timeoutMs}ms` : `${label} did not complete within ${timeoutMs}ms`);
+    this.name = "MutationTimeoutError";
+    this.label = label;
+    this.phase = phase;
+    this.timeoutMs = timeoutMs;
+  }
+}
+class MutationResultError extends Error {
+  label;
+  phase;
+  result;
+  constructor(label, phase, result, message) {
+    super(`${label} failed${phase === "server" ? " on server" : ""}: ${message}`);
+    this.name = "MutationResultError";
+    this.label = label;
+    this.phase = phase;
+    this.result = result;
+  }
+}
+function isStaleGenerationError(error) {
+  return error instanceof StaleGenerationError;
+}
+function mutationErrorMessage(result) {
+  if (!result || typeof result !== "object") return null;
+  const typed = result;
+  if (typed.type !== "error") return null;
+  return describeMutationError(typed.error);
+}
+function describeMutationError(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object") {
+    const typed = error;
+    const parts = [typed.type, typed.message].filter(part => typeof part === "string" && part.length > 0);
+    if (parts.length) return parts.join(": ");
+  }
+  return String(error);
+}
+function createMutationLifecycle(options) {
+  const queue = {
+    tail: Promise.resolve(),
+    lastErrorMessage: null,
+    coalesceSequence: /* @__PURE__ */new Map()
+  };
+  const waiters = /* @__PURE__ */new Set();
+  let generation = 0;
+  let active = false;
+  let consecutiveServerAckTimeouts = 0;
+  function stale(label) {
+    return new StaleGenerationError(label);
+  }
+  function fence() {
+    if (!active) return;
+    active = false;
+    generation += 1;
+    consecutiveServerAckTimeouts = 0;
+    queue.coalesceSequence.clear();
+    for (const waiter of [...waiters]) {
+      waiters.delete(waiter);
+      waiter.reject();
+    }
+  }
+  function activate() {
+    if (active) return;
+    generation += 1;
+    active = true;
+    consecutiveServerAckTimeouts = 0;
+    queue.lastErrorMessage = null;
+  }
+  function observeGeneration(capturedGeneration, label) {
+    let waiter;
+    const promise = new Promise((_, reject) => {
+      if (!active || capturedGeneration !== generation) {
+        reject(stale(label));
+        return;
+      }
+      waiter = {
+        reject: () => reject(stale(label))
+      };
+      waiters.add(waiter);
+      if (!active || capturedGeneration !== generation) {
+        waiters.delete(waiter);
+        waiter = void 0;
+        reject(stale(label));
+      }
+    });
+    return {
+      promise,
+      dispose() {
+        if (waiter) waiters.delete(waiter);
+      }
+    };
+  }
+  async function awaitInGeneration(input) {
+    if (!active || input.generation !== generation) throw stale(input.label);
+    let timer;
+    const generationChange = observeGeneration(input.generation, input.label);
+    try {
+      return await Promise.race([input.promise, generationChange.promise, new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new MutationTimeoutError(input.label, input.phase, input.timeoutMs)), input.timeoutMs);
+      })]);
+    } finally {
+      generationChange.dispose();
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async function settleMutationClient(mutation, label, timeoutMs, capturedGeneration, observeServerFailure) {
+    const result = await awaitInGeneration({
+      promise: mutation.client,
+      label,
+      phase: "client",
+      timeoutMs,
+      generation: capturedGeneration
+    });
+    const message = mutationErrorMessage(result);
+    if (message) throw new MutationResultError(label, "client", result, message);
+    if (observeServerFailure) {
+      mutation.server?.catch(error => {
+        if (!active || capturedGeneration !== generation) return;
+        console.warn(`[on-zero] ${label} server replication failed:`, error);
+      });
+    }
+    return result;
+  }
+  function awaitMutationClient(mutation, label, timeoutMs = 3e4) {
+    return settleMutationClient(mutation, label, timeoutMs, generation, true);
+  }
+  async function awaitMutationServer(mutation, label, timeoutMs = 3e4) {
+    const capturedGeneration = generation;
+    const clientResult = await settleMutationClient(mutation, label, timeoutMs, capturedGeneration, false);
+    if (!mutation.server) return clientResult;
+    try {
+      const serverResult = await awaitInGeneration({
+        promise: mutation.server,
+        label,
+        phase: "server",
+        timeoutMs,
+        generation: capturedGeneration
+      });
+      consecutiveServerAckTimeouts = 0;
+      const message = mutationErrorMessage(serverResult);
+      if (message) throw new MutationResultError(label, "server", serverResult, message);
+      return serverResult;
+    } catch (error) {
+      if (error instanceof MutationTimeoutError && error.phase === "server") {
+        consecutiveServerAckTimeouts += 1;
+        if (consecutiveServerAckTimeouts >= options.ackTimeoutRecoveryThreshold) {
+          options.recoverFromAckTimeout({
+            label,
+            timeoutMs,
+            consecutiveTimeouts: consecutiveServerAckTimeouts
+          });
+        }
+      }
+      throw error;
+    }
+  }
+  function enqueueBackgroundMutation(label, create, mutationOptions = {}) {
+    const capturedGeneration = generation;
+    const {
+      coalesceKey = "",
+      settle = "client",
+      timeoutMs = 12e4
+    } = mutationOptions;
+    const sequence = coalesceKey ? (queue.coalesceSequence.get(coalesceKey) ?? 0) + 1 : 0;
+    if (coalesceKey) queue.coalesceSequence.set(coalesceKey, sequence);
+    const queued = queue.tail.then(async () => {
+      if (!active || capturedGeneration !== generation) throw stale(label);
+      if (coalesceKey) {
+        if (queue.coalesceSequence.get(coalesceKey) !== sequence) return;
+        queue.coalesceSequence.delete(coalesceKey);
+      }
+      const result2 = await create();
+      if (result2 && typeof result2 === "object" && "client" in result2) {
+        const mutation = result2;
+        if (settle === "server" && mutation.server) {
+          await awaitMutationServer(mutation, label, timeoutMs);
+        } else {
+          await settleMutationClient(mutation, label, timeoutMs, capturedGeneration, true);
+        }
+      } else {
+        await result2;
+      }
+      queue.lastErrorMessage = null;
+    });
+    const result = queued.catch(error => {
+      if (isStaleGenerationError(error)) return;
+      if (!active || capturedGeneration !== generation) return;
+      const message = describeMutationError(error);
+      const alreadyLogged = queue.lastErrorMessage === message;
+      queue.lastErrorMessage = message;
+      if (!alreadyLogged) {
+        console.warn(`[on-zero] ${label} background mutation failed:`, error);
+      }
+      throw error;
+    });
+    queue.tail = result.catch(() => {});
+    return result;
+  }
+  return {
+    activate,
+    fence,
+    enqueueBackgroundMutation,
+    awaitMutationClient,
+    awaitMutationServer
+  };
+}