nolo-cli 0.8.0 → 0.9.0

package/chunk-EYEEHCU4.js

@@ -0,0 +1,3066 @@
+import {
+  getAllServers,
+  getIsDesktopApp,
+  isAbortError
+} from "./chunk-QYXLLLGL.js";
+import {
+  isLocalServerUrl
+} from "./chunk-4SN6J65J.js";
+import {
+  API_ENDPOINTS,
+  SERVERS,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// node_modules/reselect/dist/reselect.mjs
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+    let isInputSameAsOutput = false;
+    try {
+      const emptyObject = {};
+      if (resultFunc(emptyObject) === emptyObject)
+        isInputSameAsOutput = true;
+    } catch {
+    }
+    if (isInputSameAsOutput) {
+      let stack = void 0;
+      try {
+        throw new Error();
+      } catch (e) {
+        ;
+        ({ stack } = e);
+      }
+      console.warn(
+        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
+        { stack }
+      );
+    }
+  }
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+  const { memoize, memoizeOptions } = options;
+  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
+  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
+  if (!areInputSelectorResultsEqual) {
+    let stack = void 0;
+    try {
+      throw new Error();
+    } catch (e) {
+      ;
+      ({ stack } = e);
+    }
+    console.warn(
+      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
+      {
+        arguments: inputSelectorArgs,
+        firstInputs: inputSelectorResults,
+        secondInputs: inputSelectorResultsCopy,
+        stack
+      }
+    );
+  }
+};
+var globalDevModeChecks = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {
+  if (typeof object !== "object") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
+var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
+  const { identityFunctionCheck, inputStabilityCheck } = {
+    ...globalDevModeChecks,
+    ...devModeChecks
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
+      run: runIdentityFunctionCheck
+    },
+    inputStabilityCheck: {
+      shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
+      run: runInputStabilityCheck
+    }
+  };
+};
+var REDUX_PROXY_LABEL = Symbol();
+var proto = Object.getPrototypeOf({});
+var StrongRef = class {
+  constructor(value) {
+    this.value = value;
+  }
+  deref() {
+    return this.value;
+  }
+};
+var Ref = typeof WeakRef !== "undefined" ? WeakRef : StrongRef;
+var UNTERMINATED = 0;
+var TERMINATED = 1;
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function weakMapMemoize(func, options = {}) {
+  let fnNode = createCacheNode();
+  const { resultEqualityCheck } = options;
+  let lastResult;
+  let resultsCount = 0;
+  function memoized() {
+    let cacheNode = fnNode;
+    const { length } = arguments;
+    for (let i = 0, l = length; i < l; i++) {
+      const arg = arguments[i];
+      if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+        let objectCache = cacheNode.o;
+        if (objectCache === null) {
+          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
+        }
+        const objectNode = objectCache.get(arg);
+        if (objectNode === void 0) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        let primitiveCache = cacheNode.p;
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
+        }
+        const primitiveNode = primitiveCache.get(arg);
+        if (primitiveNode === void 0) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+    const terminatedNode = cacheNode;
+    let result;
+    if (cacheNode.s === TERMINATED) {
+      result = cacheNode.v;
+    } else {
+      result = func.apply(null, arguments);
+      resultsCount++;
+      if (resultEqualityCheck) {
+        const lastResultValue = lastResult?.deref?.() ?? lastResult;
+        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+          result = lastResultValue;
+          resultsCount !== 0 && resultsCount--;
+        }
+        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+        lastResult = needsWeakRef ? new Ref(result) : result;
+      }
+    }
+    terminatedNode.s = TERMINATED;
+    terminatedNode.v = result;
+    return result;
+  }
+  memoized.clearCache = () => {
+    fnNode = createCacheNode();
+    memoized.resetResultsCount();
+  };
+  memoized.resultsCount = () => resultsCount;
+  memoized.resetResultsCount = () => {
+    resultsCount = 0;
+  };
+  return memoized;
+}
+function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
+  const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
+    memoize: memoizeOrOptions,
+    memoizeOptions: memoizeOptionsFromArgs
+  } : memoizeOrOptions;
+  const createSelector2 = (...createSelectorArgs) => {
+    let recomputations = 0;
+    let dependencyRecomputations = 0;
+    let lastResult;
+    let directlyPassedOptions = {};
+    let resultFunc = createSelectorArgs.pop();
+    if (typeof resultFunc === "object") {
+      directlyPassedOptions = resultFunc;
+      resultFunc = createSelectorArgs.pop();
+    }
+    assertIsFunction(
+      resultFunc,
+      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`
+    );
+    const combinedOptions = {
+      ...createSelectorCreatorOptions,
+      ...directlyPassedOptions
+    };
+    const {
+      memoize,
+      memoizeOptions = [],
+      argsMemoize = weakMapMemoize,
+      argsMemoizeOptions = [],
+      devModeChecks = {}
+    } = combinedOptions;
+    const finalMemoizeOptions = ensureIsArray(memoizeOptions);
+    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
+    const dependencies = getDependencies(createSelectorArgs);
+    const memoizedResultFunc = memoize(function recomputationWrapper() {
+      recomputations++;
+      return resultFunc.apply(
+        null,
+        arguments
+      );
+    }, ...finalMemoizeOptions);
+    let firstRun = true;
+    const selector = argsMemoize(function dependenciesChecker() {
+      dependencyRecomputations++;
+      const inputSelectorResults = collectInputSelectorResults(
+        dependencies,
+        arguments
+      );
+      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
+      if (process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
+        if (identityFunctionCheck.shouldRun) {
+          identityFunctionCheck.run(
+            resultFunc,
+            inputSelectorResults,
+            lastResult
+          );
+        }
+        if (inputStabilityCheck.shouldRun) {
+          const inputSelectorResultsCopy = collectInputSelectorResults(
+            dependencies,
+            arguments
+          );
+          inputStabilityCheck.run(
+            { inputSelectorResults, inputSelectorResultsCopy },
+            { memoize, memoizeOptions: finalMemoizeOptions },
+            arguments
+          );
+        }
+        if (firstRun)
+          firstRun = false;
+      }
+      return lastResult;
+    }, ...finalArgsMemoizeOptions);
+    return Object.assign(selector, {
+      resultFunc,
+      memoizedResultFunc,
+      dependencies,
+      dependencyRecomputations: () => dependencyRecomputations,
+      resetDependencyRecomputations: () => {
+        dependencyRecomputations = 0;
+      },
+      lastResult: () => lastResult,
+      recomputations: () => recomputations,
+      resetRecomputations: () => {
+        recomputations = 0;
+      },
+      memoize,
+      argsMemoize
+    });
+  };
+  Object.assign(createSelector2, {
+    withTypes: () => createSelector2
+  });
+  return createSelector2;
+}
+var createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);
+var createStructuredSelector = Object.assign(
+  (inputSelectorsObject, selectorCreator = createSelector) => {
+    assertIsObject(
+      inputSelectorsObject,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`
+    );
+    const inputSelectorKeys = Object.keys(inputSelectorsObject);
+    const dependencies = inputSelectorKeys.map(
+      (key) => inputSelectorsObject[key]
+    );
+    const structuredSelector = selectorCreator(
+      dependencies,
+      (...inputSelectorResults) => {
+        return inputSelectorResults.reduce((composition, value, index) => {
+          composition[inputSelectorKeys[index]] = value;
+          return composition;
+        }, {});
+      }
+    );
+    return structuredSelector;
+  },
+  { withTypes: () => createStructuredSelector }
+);
+
+// node_modules/redux/dist/redux.mjs
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto2 = obj;
+  while (Object.getPrototypeOf(proto2) !== null) {
+    proto2 = Object.getPrototypeOf(proto2);
+  }
+  return Object.getPrototypeOf(obj) === proto2 || Object.getPrototypeOf(obj) === null;
+}
+function compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
+  }
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
+}
+function isAction(action) {
+  return isPlainObject(action) && "type" in action && typeof action.type === "string";
+}
+
+// node_modules/immer/dist/immer.mjs
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+var errors = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = errors[error];
+    const msg = typeof e === "function" ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject2(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject2(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto2 = getPrototypeOf(value);
+  if (proto2 === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto2, "constructor") && proto2.constructor;
+  if (Ctor === Object)
+    return true;
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function each(obj, iter) {
+  if (getArchtype(obj) === 0) {
+    Reflect.ownKeys(obj).forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2)
+    thing.set(propOrOldValue, value);
+  else if (t === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = isPlainObject2(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = Object.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc.writable === false) {
+        desc.writable = true;
+        desc.configurable = true;
+      }
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          configurable: true,
+          writable: true,
+          // could live with !!desc.set as well here...
+          enumerable: desc.enumerable,
+          value: base[key]
+        };
+    }
+    return Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto2 = getPrototypeOf(base);
+    if (proto2 !== null && isPlain) {
+      return { ...base };
+    }
+    const obj = Object.create(proto2);
+    return Object.assign(obj, base);
+  }
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+  }
+  Object.freeze(obj);
+  if (deep)
+    Object.entries(obj).forEach(([key, value]) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+function isFrozen(obj) {
+  return Object.isFrozen(obj);
+}
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
+    }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
+    }
+  }
+  return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
+    die(5);
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? `value` in desc ? desc.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto2 = getPrototypeOf(source);
+  while (proto2) {
+    const desc = Object.getOwnPropertyDescriptor(proto2, prop);
+    if (desc)
+      return desc;
+    proto2 = getPrototypeOf(proto2);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.produce = (base, recipe, patchListener) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || typeof base !== "object") {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (typeof config?.autoFreeze === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof config?.useStrictShallowCopy === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
+    }
+    if (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(copy, (key, childValue) => {
+    set(copy, key, currentImpl(childValue));
+  });
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+var produceWithPatches = immer.produceWithPatches.bind(
+  immer
+);
+var setAutoFreeze = immer.setAutoFreeze.bind(immer);
+var setUseStrictShallowCopy = immer.setUseStrictShallowCopy.bind(immer);
+var applyPatches = immer.applyPatches.bind(immer);
+var createDraft = immer.createDraft.bind(immer);
+var finishDraft = immer.finishDraft.bind(immer);
+
+// node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
+var createDraftSafeSelectorCreator = (...args) => {
+  const createSelector2 = createSelectorCreator(...args);
+  const createDraftSafeSelector2 = Object.assign((...args2) => {
+    const selector = createSelector2(...args2);
+    const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);
+    Object.assign(wrappedSelector, selector);
+    return wrappedSelector;
+  }, {
+    withTypes: () => createDraftSafeSelector2
+  });
+  return createDraftSafeSelector2;
+};
+var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(weakMapMemoize);
+var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length === 0) return void 0;
+  if (typeof arguments[0] === "object") return compose;
+  return compose.apply(null, arguments);
+};
+var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
+  return function(noop3) {
+    return noop3;
+  };
+};
+var hasMatchFunction = (v) => {
+  return v && typeof v.match === "function";
+};
+function createAction(type, prepareAction) {
+  function actionCreator(...args) {
+    if (prepareAction) {
+      let prepared = prepareAction(...args);
+      if (!prepared) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
+      }
+      return {
+        type,
+        payload: prepared.payload,
+        ..."meta" in prepared && {
+          meta: prepared.meta
+        },
+        ..."error" in prepared && {
+          error: prepared.error
+        }
+      };
+    }
+    return {
+      type,
+      payload: args[0]
+    };
+  }
+  actionCreator.toString = () => `${type}`;
+  actionCreator.type = type;
+  actionCreator.match = (action) => isAction(action) && action.type === type;
+  return actionCreator;
+}
+function isFSA(action) {
+  return isAction(action) && Object.keys(action).every(isValidKey);
+}
+function isValidKey(key) {
+  return ["type", "payload", "error", "meta"].indexOf(key) > -1;
+}
+function freezeDraftable(val) {
+  return isDraftable(val) ? produce(val, () => {
+  }) : val;
+}
+function getOrInsertComputed(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
+}
+function executeReducerBuilderCallback(builderCallback) {
+  const actionsMap = {};
+  const actionMatchers = [];
+  let defaultCaseReducer;
+  const builder = {
+    addCase(typeOrActionCreator, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (actionMatchers.length > 0) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        }
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+      if (!type) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
+      }
+      if (type in actionsMap) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
+      }
+      actionsMap[type] = reducer;
+      return builder;
+    },
+    addMatcher(matcher, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      actionMatchers.push({
+        matcher,
+        reducer
+      });
+      return builder;
+    },
+    addDefaultCase(reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
+        }
+      }
+      defaultCaseReducer = reducer;
+      return builder;
+    }
+  };
+  builderCallback(builder);
+  return [actionsMap, actionMatchers, defaultCaseReducer];
+}
+function isStateFunction(x) {
+  return typeof x === "function";
+}
+function createReducer(initialState, mapOrBuilderCallback) {
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof mapOrBuilderCallback === "object") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+    }
+  }
+  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
+  let getInitialState;
+  if (isStateFunction(initialState)) {
+    getInitialState = () => freezeDraftable(initialState());
+  } else {
+    const frozenInitialState = freezeDraftable(initialState);
+    getInitialState = () => frozenInitialState;
+  }
+  function reducer(state = getInitialState(), action) {
+    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
+      matcher
+    }) => matcher(action)).map(({
+      reducer: reducer2
+    }) => reducer2)];
+    if (caseReducers.filter((cr) => !!cr).length === 0) {
+      caseReducers = [finalDefaultCaseReducer];
+    }
+    return caseReducers.reduce((previousState, caseReducer) => {
+      if (caseReducer) {
+        if (isDraft(previousState)) {
+          const draft = previousState;
+          const result = caseReducer(draft, action);
+          if (result === void 0) {
+            return previousState;
+          }
+          return result;
+        } else if (!isDraftable(previousState)) {
+          const result = caseReducer(previousState, action);
+          if (result === void 0) {
+            if (previousState === null) {
+              return previousState;
+            }
+            throw Error("A case reducer on a non-draftable value must not return undefined");
+          }
+          return result;
+        } else {
+          return produce(previousState, (draft) => {
+            return caseReducer(draft, action);
+          });
+        }
+      }
+      return previousState;
+    }, state);
+  }
+  reducer.getInitialState = getInitialState;
+  return reducer;
+}
+var matches = (matcher, action) => {
+  if (hasMatchFunction(matcher)) {
+    return matcher.match(action);
+  } else {
+    return matcher(action);
+  }
+};
+function isAnyOf(...matchers) {
+  return (action) => {
+    return matchers.some((matcher) => matches(matcher, action));
+  };
+}
+var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+var commonProperties = ["name", "message", "stack", "code"];
+var RejectWithValue = class {
+  constructor(payload, meta) {
+    this.payload = payload;
+    this.meta = meta;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+};
+var FulfillWithMeta = class {
+  constructor(payload, meta) {
+    this.payload = payload;
+    this.meta = meta;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+};
+var miniSerializeError = (value) => {
+  if (typeof value === "object" && value !== null) {
+    const simpleError = {};
+    for (const property of commonProperties) {
+      if (typeof value[property] === "string") {
+        simpleError[property] = value[property];
+      }
+    }
+    return simpleError;
+  }
+  return {
+    message: String(value)
+  };
+};
+var createAsyncThunk = /* @__PURE__ */ (() => {
+  function createAsyncThunk2(typePrefix, payloadCreator, options) {
+    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
+      payload,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "fulfilled"
+      }
+    }));
+    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
+      payload: void 0,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "pending"
+      }
+    }));
+    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
+      payload,
+      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        rejectedWithValue: !!payload,
+        requestStatus: "rejected",
+        aborted: error?.name === "AbortError",
+        condition: error?.name === "ConditionError"
+      }
+    }));
+    function actionCreator(arg) {
+      return (dispatch, getState, extra) => {
+        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
+        const abortController = new AbortController();
+        let abortHandler;
+        let abortReason;
+        function abort(reason) {
+          abortReason = reason;
+          abortController.abort();
+        }
+        const promise = async function() {
+          let finalAction;
+          try {
+            let conditionResult = options?.condition?.(arg, {
+              getState,
+              extra
+            });
+            if (isThenable(conditionResult)) {
+              conditionResult = await conditionResult;
+            }
+            if (conditionResult === false || abortController.signal.aborted) {
+              throw {
+                name: "ConditionError",
+                message: "Aborted due to condition callback returning false."
+              };
+            }
+            const abortedPromise = new Promise((_, reject) => {
+              abortHandler = () => {
+                reject({
+                  name: "AbortError",
+                  message: abortReason || "Aborted"
+                });
+              };
+              abortController.signal.addEventListener("abort", abortHandler);
+            });
+            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
+              requestId,
+              arg
+            }, {
+              getState,
+              extra
+            })));
+            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
+              dispatch,
+              getState,
+              extra,
+              requestId,
+              signal: abortController.signal,
+              abort,
+              rejectWithValue: (value, meta) => {
+                return new RejectWithValue(value, meta);
+              },
+              fulfillWithValue: (value, meta) => {
+                return new FulfillWithMeta(value, meta);
+              }
+            })).then((result) => {
+              if (result instanceof RejectWithValue) {
+                throw result;
+              }
+              if (result instanceof FulfillWithMeta) {
+                return fulfilled(result.payload, requestId, arg, result.meta);
+              }
+              return fulfilled(result, requestId, arg);
+            })]);
+          } catch (err) {
+            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
+          } finally {
+            if (abortHandler) {
+              abortController.signal.removeEventListener("abort", abortHandler);
+            }
+          }
+          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
+          if (!skipDispatch) {
+            dispatch(finalAction);
+          }
+          return finalAction;
+        }();
+        return Object.assign(promise, {
+          abort,
+          requestId,
+          arg,
+          unwrap() {
+            return promise.then(unwrapResult);
+          }
+        });
+      };
+    }
+    return Object.assign(actionCreator, {
+      pending,
+      rejected,
+      fulfilled,
+      settled: isAnyOf(rejected, fulfilled),
+      typePrefix
+    });
+  }
+  createAsyncThunk2.withTypes = () => createAsyncThunk2;
+  return createAsyncThunk2;
+})();
+function unwrapResult(action) {
+  if (action.meta && action.meta.rejectedWithValue) {
+    throw action.payload;
+  }
+  if (action.error) {
+    throw action.error;
+  }
+  return action.payload;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+var asyncThunkCreator = {
+  [asyncThunkSymbol]: createAsyncThunk
+};
+function getType(slice, actionKey) {
+  return `${slice}/${actionKey}`;
+}
+function buildCreateSlice({
+  creators
+} = {}) {
+  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
+  return function createSlice2(options) {
+    const {
+      name,
+      reducerPath = name
+    } = options;
+    if (!name) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+      if (options.initialState === void 0) {
+        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+      }
+    }
+    const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
+    const reducerNames = Object.keys(reducers);
+    const context = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    };
+    const contextMethods = {
+      addCase(typeOrActionCreator, reducer2) {
+        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+        if (!type) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
+        }
+        if (type in context.sliceCaseReducersByType) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
+        }
+        context.sliceCaseReducersByType[type] = reducer2;
+        return contextMethods;
+      },
+      addMatcher(matcher, reducer2) {
+        context.sliceMatchers.push({
+          matcher,
+          reducer: reducer2
+        });
+        return contextMethods;
+      },
+      exposeAction(name2, actionCreator) {
+        context.actionCreators[name2] = actionCreator;
+        return contextMethods;
+      },
+      exposeCaseReducer(name2, reducer2) {
+        context.sliceCaseReducersByName[name2] = reducer2;
+        return contextMethods;
+      }
+    };
+    reducerNames.forEach((reducerName) => {
+      const reducerDefinition = reducers[reducerName];
+      const reducerDetails = {
+        reducerName,
+        type: getType(name, reducerName),
+        createNotation: typeof options.reducers === "function"
+      };
+      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
+        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
+      } else {
+        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
+      }
+    });
+    function buildReducer() {
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof options.extraReducers === "object") {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+        }
+      }
+      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
+      const finalCaseReducers = {
+        ...extraReducers,
+        ...context.sliceCaseReducersByType
+      };
+      return createReducer(options.initialState, (builder) => {
+        for (let key in finalCaseReducers) {
+          builder.addCase(key, finalCaseReducers[key]);
+        }
+        for (let sM of context.sliceMatchers) {
+          builder.addMatcher(sM.matcher, sM.reducer);
+        }
+        for (let m of actionMatchers) {
+          builder.addMatcher(m.matcher, m.reducer);
+        }
+        if (defaultCaseReducer) {
+          builder.addDefaultCase(defaultCaseReducer);
+        }
+      });
+    }
+    const selectSelf = (state) => state;
+    const injectedSelectorCache = /* @__PURE__ */ new Map();
+    let _reducer;
+    function reducer(state, action) {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer(state, action);
+    }
+    function getInitialState() {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer.getInitialState();
+    }
+    function makeSelectorProps(reducerPath2, injected = false) {
+      function selectSlice(state) {
+        let sliceState = state[reducerPath2];
+        if (typeof sliceState === "undefined") {
+          if (injected) {
+            sliceState = getInitialState();
+          } else if (process.env.NODE_ENV !== "production") {
+            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
+          }
+        }
+        return sliceState;
+      }
+      function getSelectors(selectState = selectSelf) {
+        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
+        return getOrInsertComputed(selectorCache, selectState, () => {
+          const map = {};
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
+            map[name2] = wrapSelector(selector, selectState, getInitialState, injected);
+          }
+          return map;
+        });
+      }
+      return {
+        reducerPath: reducerPath2,
+        getSelectors,
+        get selectors() {
+          return getSelectors(selectSlice);
+        },
+        selectSlice
+      };
+    }
+    const slice = {
+      name,
+      reducer,
+      actions: context.actionCreators,
+      caseReducers: context.sliceCaseReducersByName,
+      getInitialState,
+      ...makeSelectorProps(reducerPath),
+      injectInto(injectable, {
+        reducerPath: pathOpt,
+        ...config
+      } = {}) {
+        const newReducerPath = pathOpt ?? reducerPath;
+        injectable.inject({
+          reducerPath: newReducerPath,
+          reducer
+        }, config);
+        return {
+          ...slice,
+          ...makeSelectorProps(newReducerPath, true)
+        };
+      }
+    };
+    return slice;
+  };
+}
+function wrapSelector(selector, selectState, getInitialState, injected) {
+  function wrapper(rootState, ...args) {
+    let sliceState = selectState(rootState);
+    if (typeof sliceState === "undefined") {
+      if (injected) {
+        sliceState = getInitialState();
+      } else if (process.env.NODE_ENV !== "production") {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
+      }
+    }
+    return selector(sliceState, ...args);
+  }
+  wrapper.unwrapped = selector;
+  return wrapper;
+}
+function buildReducerCreators() {
+  function asyncThunk(payloadCreator, config) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator,
+      ...config
+    };
+  }
+  asyncThunk.withTypes = () => asyncThunk;
+  return {
+    reducer(caseReducer) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [caseReducer.name](...args) {
+          return caseReducer(...args);
+        }
+      }[caseReducer.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(prepare, reducer) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare,
+        reducer
+      };
+    },
+    asyncThunk
+  };
+}
+function handleNormalReducerDefinition({
+  type,
+  reducerName,
+  createNotation
+}, maybeReducerWithPrepare, context) {
+  let caseReducer;
+  let prepareCallback;
+  if ("reducer" in maybeReducerWithPrepare) {
+    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    }
+    caseReducer = maybeReducerWithPrepare.reducer;
+    prepareCallback = maybeReducerWithPrepare.prepare;
+  } else {
+    caseReducer = maybeReducerWithPrepare;
+  }
+  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
+}
+function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "asyncThunk";
+}
+function isCaseReducerWithPrepareDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare";
+}
+function handleThunkCaseReducerDefinition({
+  type,
+  reducerName
+}, reducerDefinition, context, cAT) {
+  if (!cAT) {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  }
+  const {
+    payloadCreator,
+    fulfilled,
+    pending,
+    rejected,
+    settled,
+    options
+  } = reducerDefinition;
+  const thunk = cAT(type, payloadCreator, options);
+  context.exposeAction(reducerName, thunk);
+  if (fulfilled) {
+    context.addCase(thunk.fulfilled, fulfilled);
+  }
+  if (pending) {
+    context.addCase(thunk.pending, pending);
+  }
+  if (rejected) {
+    context.addCase(thunk.rejected, rejected);
+  }
+  if (settled) {
+    context.addMatcher(thunk.settled, settled);
+  }
+  context.exposeCaseReducer(reducerName, {
+    fulfilled: fulfilled || noop,
+    pending: pending || noop,
+    rejected: rejected || noop,
+    settled: settled || noop
+  });
+}
+function noop() {
+}
+function getInitialEntityState() {
+  return {
+    ids: [],
+    entities: {}
+  };
+}
+function createInitialStateFactory(stateAdapter) {
+  function getInitialState(additionalState = {}, entities) {
+    const state = Object.assign(getInitialEntityState(), additionalState);
+    return entities ? stateAdapter.setAll(state, entities) : state;
+  }
+  return {
+    getInitialState
+  };
+}
+function createSelectorsFactory() {
+  function getSelectors(selectState, options = {}) {
+    const {
+      createSelector: createSelector2 = createDraftSafeSelector
+    } = options;
+    const selectIds = (state) => state.ids;
+    const selectEntities = (state) => state.entities;
+    const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
+    const selectId = (_, id) => id;
+    const selectById = (entities, id) => entities[id];
+    const selectTotal = createSelector2(selectIds, (ids) => ids.length);
+    if (!selectState) {
+      return {
+        selectIds,
+        selectEntities,
+        selectAll,
+        selectTotal,
+        selectById: createSelector2(selectEntities, selectId, selectById)
+      };
+    }
+    const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
+    return {
+      selectIds: createSelector2(selectState, selectIds),
+      selectEntities: selectGlobalizedEntities,
+      selectAll: createSelector2(selectState, selectAll),
+      selectTotal: createSelector2(selectState, selectTotal),
+      selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
+    };
+  }
+  return {
+    getSelectors
+  };
+}
+var isDraftTyped = isDraft;
+function createSingleArgumentStateOperator(mutator) {
+  const operator = createStateOperator((_, state) => mutator(state));
+  return function operation(state) {
+    return operator(state, void 0);
+  };
+}
+function createStateOperator(mutator) {
+  return function operation(state, arg) {
+    function isPayloadActionArgument(arg2) {
+      return isFSA(arg2);
+    }
+    const runMutator = (draft) => {
+      if (isPayloadActionArgument(arg)) {
+        mutator(arg.payload, draft);
+      } else {
+        mutator(arg, draft);
+      }
+    };
+    if (isDraftTyped(state)) {
+      runMutator(state);
+      return state;
+    }
+    return produce(state, runMutator);
+  };
+}
+function selectIdValue(entity, selectId) {
+  const key = selectId(entity);
+  if (process.env.NODE_ENV !== "production" && key === void 0) {
+    console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
+  }
+  return key;
+}
+function ensureEntitiesArray(entities) {
+  if (!Array.isArray(entities)) {
+    entities = Object.values(entities);
+  }
+  return entities;
+}
+function getCurrent(value) {
+  return isDraft(value) ? current(value) : value;
+}
+function splitAddedUpdatedEntities(newEntities, selectId, state) {
+  newEntities = ensureEntitiesArray(newEntities);
+  const existingIdsArray = getCurrent(state.ids);
+  const existingIds = new Set(existingIdsArray);
+  const added = [];
+  const updated = [];
+  for (const entity of newEntities) {
+    const id = selectIdValue(entity, selectId);
+    if (existingIds.has(id)) {
+      updated.push({
+        id,
+        changes: entity
+      });
+    } else {
+      added.push(entity);
+    }
+  }
+  return [added, updated, existingIdsArray];
+}
+function createUnsortedStateAdapter(selectId) {
+  function addOneMutably(entity, state) {
+    const key = selectIdValue(entity, selectId);
+    if (key in state.entities) {
+      return;
+    }
+    state.ids.push(key);
+    state.entities[key] = entity;
+  }
+  function addManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    for (const entity of newEntities) {
+      addOneMutably(entity, state);
+    }
+  }
+  function setOneMutably(entity, state) {
+    const key = selectIdValue(entity, selectId);
+    if (!(key in state.entities)) {
+      state.ids.push(key);
+    }
+    ;
+    state.entities[key] = entity;
+  }
+  function setManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    for (const entity of newEntities) {
+      setOneMutably(entity, state);
+    }
+  }
+  function setAllMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    state.ids = [];
+    state.entities = {};
+    addManyMutably(newEntities, state);
+  }
+  function removeOneMutably(key, state) {
+    return removeManyMutably([key], state);
+  }
+  function removeManyMutably(keys, state) {
+    let didMutate = false;
+    keys.forEach((key) => {
+      if (key in state.entities) {
+        delete state.entities[key];
+        didMutate = true;
+      }
+    });
+    if (didMutate) {
+      state.ids = state.ids.filter((id) => id in state.entities);
+    }
+  }
+  function removeAllMutably(state) {
+    Object.assign(state, {
+      ids: [],
+      entities: {}
+    });
+  }
+  function takeNewKey(keys, update, state) {
+    const original3 = state.entities[update.id];
+    if (original3 === void 0) {
+      return false;
+    }
+    const updated = Object.assign({}, original3, update.changes);
+    const newKey = selectIdValue(updated, selectId);
+    const hasNewKey = newKey !== update.id;
+    if (hasNewKey) {
+      keys[update.id] = newKey;
+      delete state.entities[update.id];
+    }
+    ;
+    state.entities[newKey] = updated;
+    return hasNewKey;
+  }
+  function updateOneMutably(update, state) {
+    return updateManyMutably([update], state);
+  }
+  function updateManyMutably(updates, state) {
+    const newKeys = {};
+    const updatesPerEntity = {};
+    updates.forEach((update) => {
+      if (update.id in state.entities) {
+        updatesPerEntity[update.id] = {
+          id: update.id,
+          // Spreads ignore falsy values, so this works even if there isn't
+          // an existing update already at this key
+          changes: {
+            ...updatesPerEntity[update.id]?.changes,
+            ...update.changes
+          }
+        };
+      }
+    });
+    updates = Object.values(updatesPerEntity);
+    const didMutateEntities = updates.length > 0;
+    if (didMutateEntities) {
+      const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;
+      if (didMutateIds) {
+        state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
+      }
+    }
+  }
+  function upsertOneMutably(entity, state) {
+    return upsertManyMutably([entity], state);
+  }
+  function upsertManyMutably(newEntities, state) {
+    const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);
+    updateManyMutably(updated, state);
+    addManyMutably(added, state);
+  }
+  return {
+    removeAll: createSingleArgumentStateOperator(removeAllMutably),
+    addOne: createStateOperator(addOneMutably),
+    addMany: createStateOperator(addManyMutably),
+    setOne: createStateOperator(setOneMutably),
+    setMany: createStateOperator(setManyMutably),
+    setAll: createStateOperator(setAllMutably),
+    updateOne: createStateOperator(updateOneMutably),
+    updateMany: createStateOperator(updateManyMutably),
+    upsertOne: createStateOperator(upsertOneMutably),
+    upsertMany: createStateOperator(upsertManyMutably),
+    removeOne: createStateOperator(removeOneMutably),
+    removeMany: createStateOperator(removeManyMutably)
+  };
+}
+function findInsertIndex(sortedItems, item, comparisonFunction) {
+  let lowIndex = 0;
+  let highIndex = sortedItems.length;
+  while (lowIndex < highIndex) {
+    let middleIndex = lowIndex + highIndex >>> 1;
+    const currentItem = sortedItems[middleIndex];
+    const res = comparisonFunction(item, currentItem);
+    if (res >= 0) {
+      lowIndex = middleIndex + 1;
+    } else {
+      highIndex = middleIndex;
+    }
+  }
+  return lowIndex;
+}
+function insert(sortedItems, item, comparisonFunction) {
+  const insertAtIndex = findInsertIndex(sortedItems, item, comparisonFunction);
+  sortedItems.splice(insertAtIndex, 0, item);
+  return sortedItems;
+}
+function createSortedStateAdapter(selectId, comparer) {
+  const {
+    removeOne,
+    removeMany,
+    removeAll
+  } = createUnsortedStateAdapter(selectId);
+  function addOneMutably(entity, state) {
+    return addManyMutably([entity], state);
+  }
+  function addManyMutably(newEntities, state, existingIds) {
+    newEntities = ensureEntitiesArray(newEntities);
+    const existingKeys = new Set(existingIds ?? getCurrent(state.ids));
+    const models = newEntities.filter((model) => !existingKeys.has(selectIdValue(model, selectId)));
+    if (models.length !== 0) {
+      mergeFunction(state, models);
+    }
+  }
+  function setOneMutably(entity, state) {
+    return setManyMutably([entity], state);
+  }
+  function setManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    if (newEntities.length !== 0) {
+      for (const item of newEntities) {
+        delete state.entities[selectId(item)];
+      }
+      mergeFunction(state, newEntities);
+    }
+  }
+  function setAllMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    state.entities = {};
+    state.ids = [];
+    addManyMutably(newEntities, state, []);
+  }
+  function updateOneMutably(update, state) {
+    return updateManyMutably([update], state);
+  }
+  function updateManyMutably(updates, state) {
+    let appliedUpdates = false;
+    let replacedIds = false;
+    for (let update of updates) {
+      const entity = state.entities[update.id];
+      if (!entity) {
+        continue;
+      }
+      appliedUpdates = true;
+      Object.assign(entity, update.changes);
+      const newId = selectId(entity);
+      if (update.id !== newId) {
+        replacedIds = true;
+        delete state.entities[update.id];
+        const oldIndex = state.ids.indexOf(update.id);
+        state.ids[oldIndex] = newId;
+        state.entities[newId] = entity;
+      }
+    }
+    if (appliedUpdates) {
+      mergeFunction(state, [], appliedUpdates, replacedIds);
+    }
+  }
+  function upsertOneMutably(entity, state) {
+    return upsertManyMutably([entity], state);
+  }
+  function upsertManyMutably(newEntities, state) {
+    const [added, updated, existingIdsArray] = splitAddedUpdatedEntities(newEntities, selectId, state);
+    if (updated.length) {
+      updateManyMutably(updated, state);
+    }
+    if (added.length) {
+      addManyMutably(added, state, existingIdsArray);
+    }
+  }
+  function areArraysEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] === b[i]) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+  const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
+    const currentEntities = getCurrent(state.entities);
+    const currentIds = getCurrent(state.ids);
+    const stateEntities = state.entities;
+    let ids = currentIds;
+    if (replacedIds) {
+      ids = new Set(currentIds);
+    }
+    let sortedEntities = [];
+    for (const id of ids) {
+      const entity = currentEntities[id];
+      if (entity) {
+        sortedEntities.push(entity);
+      }
+    }
+    const wasPreviouslyEmpty = sortedEntities.length === 0;
+    for (const item of addedItems) {
+      stateEntities[selectId(item)] = item;
+      if (!wasPreviouslyEmpty) {
+        insert(sortedEntities, item, comparer);
+      }
+    }
+    if (wasPreviouslyEmpty) {
+      sortedEntities = addedItems.slice().sort(comparer);
+    } else if (appliedUpdates) {
+      sortedEntities.sort(comparer);
+    }
+    const newSortedIds = sortedEntities.map(selectId);
+    if (!areArraysEqual(currentIds, newSortedIds)) {
+      state.ids = newSortedIds;
+    }
+  };
+  return {
+    removeOne,
+    removeMany,
+    removeAll,
+    addOne: createStateOperator(addOneMutably),
+    updateOne: createStateOperator(updateOneMutably),
+    upsertOne: createStateOperator(upsertOneMutably),
+    setOne: createStateOperator(setOneMutably),
+    setMany: createStateOperator(setManyMutably),
+    setAll: createStateOperator(setAllMutably),
+    addMany: createStateOperator(addManyMutably),
+    updateMany: createStateOperator(updateManyMutably),
+    upsertMany: createStateOperator(upsertManyMutably)
+  };
+}
+function createEntityAdapter(options = {}) {
+  const {
+    selectId,
+    sortComparer
+  } = {
+    sortComparer: false,
+    selectId: (instance) => instance.id,
+    ...options
+  };
+  const stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);
+  const stateFactory = createInitialStateFactory(stateAdapter);
+  const selectorsFactory = createSelectorsFactory();
+  return {
+    selectId,
+    sortComparer,
+    ...stateFactory,
+    ...selectorsFactory,
+    ...stateAdapter
+  };
+}
+var listener = "listener";
+var completed = "completed";
+var cancelled = "cancelled";
+var taskCancelled = `task-${cancelled}`;
+var taskCompleted = `task-${completed}`;
+var listenerCancelled = `${listener}-${cancelled}`;
+var listenerCompleted = `${listener}-${completed}`;
+var {
+  assign
+} = Object;
+var alm = "listenerMiddleware";
+var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
+  withTypes: () => addListener
+});
+var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
+var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
+  withTypes: () => removeListener
+});
+var ORIGINAL_STATE = Symbol.for("rtk-state-proxy-original");
+function formatProdErrorMessage(code) {
+  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+
+// packages/identity/selectors.local.ts
+var LOCAL_USER_ID = process.env.NOLO_LOCAL_USER_ID || process.env.NOLO_USER_ID || "local";
+var LOCAL_USER = {
+  userId: LOCAL_USER_ID,
+  username: "Local User"
+};
+var selectIdentityUserId = (state) => LOCAL_USER_ID;
+var selectIdentityToken = (state) => {
+  if (state?.auth?.currentToken) return state.auth.currentToken;
+  return void 0;
+};
+var selectIdentityUser = (state) => LOCAL_USER;
+
+// packages/app/stateViews/runtime.ts
+var selectCurrentToken = (state) => {
+  if (!state?.auth) return void 0;
+  const token = selectIdentityToken(state);
+  return typeof token === "string" ? token : void 0;
+};
+var selectCurrentUserId = (state) => {
+  if (!state?.auth) return void 0;
+  const userId = selectIdentityUserId(state);
+  return typeof userId === "string" ? userId : void 0;
+};
+var EMPTY_SYNC_SERVERS = [];
+var selectRuntimeRemoteServer = (state) => {
+  const configuredServer = normalizeKnownServerOrigin(state.settings?.currentServer) ?? void 0;
+  if (!getIsDesktopApp()) return configuredServer || SERVERS.MAIN;
+  return isLocalServerUrl(configuredServer) ? SERVERS.MAIN : configuredServer || SERVERS.MAIN;
+};
+var selectConfiguredSyncServers = (state) => state.settings?.syncServers;
+var selectRuntimeRemoteSyncServers = createSelector(
+  [selectConfiguredSyncServers],
+  (syncServers) => {
+    if (!Array.isArray(syncServers) || syncServers.length === 0) {
+      return EMPTY_SYNC_SERVERS;
+    }
+    const normalized = syncServers.map(normalizeKnownServerOrigin).filter((server) => !!server);
+    if (!getIsDesktopApp()) return normalized;
+    return normalized.filter((server) => !isLocalServerUrl(server));
+  }
+);
+var selectLocalRuntimeOrigin = () => {
+  if (typeof window !== "undefined" && typeof window.location?.origin === "string" && /^https?:\/\//.test(window.location.origin)) {
+    return window.location.origin.replace(/\/+$/, "");
+  }
+  return void 0;
+};
+var selectRuntimeSnapshot = createSelector(
+  [
+    selectCurrentToken,
+    selectCurrentUserId,
+    selectRuntimeRemoteServer,
+    selectRuntimeRemoteSyncServers,
+    selectLocalRuntimeOrigin
+  ],
+  (currentToken, currentUserId, currentServer, syncServers, localRuntimeOrigin) => ({
+    currentToken,
+    currentUserId,
+    currentServer,
+    syncServers,
+    localRuntimeOrigin
+  })
+);
+var selectRuntimeCurrentServer = createSelector(
+  [selectRuntimeSnapshot],
+  (runtime) => runtime.currentServer
+);
+var selectRuntimeRemoteServers = createSelector(
+  [selectRuntimeSnapshot],
+  (runtime) => getAllServers(runtime.currentServer, runtime.syncServers)
+);
+
+// packages/database/runtimeServerContext.ts
+var getRuntimeServerContext = (state, preferredServerOrigin) => {
+  const {
+    currentToken,
+    currentUserId,
+    currentServer,
+    syncServers = []
+  } = selectRuntimeSnapshot(state);
+  return {
+    currentToken,
+    currentUserId,
+    currentServer,
+    syncServers,
+    userAuthorityRegistry: resolveRuntimeUserAuthorityRegistry(state),
+    remoteServers: getAllServers(
+      currentServer,
+      syncServers,
+      preferredServerOrigin
+    )
+  };
+};
+var resolveRuntimeUserAuthorityRegistry = (state) => {
+  const settingsRegistry = state.settings?.userAuthorityRegistry;
+  if (settingsRegistry && typeof settingsRegistry === "object") {
+    return settingsRegistry;
+  }
+  const userRegistry = state.auth?.currentUser?.authorityRegistry;
+  if (userRegistry && typeof userRegistry === "object") {
+    return userRegistry;
+  }
+  return void 0;
+};
+
+// packages/database/requests.ts
+var TIMEOUT = 5e3;
+var logRequestFailure = (level, message) => {
+  if (level === "silent") return;
+  if (level === "warn") {
+    console.warn(message);
+    return;
+  }
+  if (level === "info") {
+    console.info(message);
+    return;
+  }
+  console.error(message);
+};
+var noloRequest = async (server, config, state, signal) => {
+  const headers = config.headers || {
+    "Content-Type": "application/json"
+  };
+  const token = state?.auth?.currentToken;
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return fetch(server + config.url, {
+    method: config.method || "GET",
+    headers,
+    body: config.body,
+    signal,
+    // 传递 AbortSignal
+    ...config.keepalive ? { keepalive: true } : {}
+  });
+};
+var noloPatchRequest = async (server, dbKey, updates, state, signal, options) => {
+  const failureLogLevel = options?.failureLogLevel ?? "error";
+  try {
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/patch/${dbKey}`,
+        method: "PATCH",
+        body: JSON.stringify(updates)
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      logRequestFailure(
+        failureLogLevel,
+        `PATCH request failed for ${dbKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error) {
+    if (!isAbortError(error)) {
+      logRequestFailure(
+        failureLogLevel,
+        `PATCH request failed for ${dbKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return false;
+  }
+};
+var noloWriteRequest = async (server, writeConfig, state, signal, options) => {
+  const { data, customKey, userId, indexKeys } = writeConfig;
+  const failureLogLevel = options?.failureLogLevel ?? "error";
+  try {
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/write/`,
+        method: "POST",
+        body: JSON.stringify({ data, customKey, userId, indexKeys })
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      logRequestFailure(
+        failureLogLevel,
+        `Write request failed for ${customKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error) {
+    if (!isAbortError(error)) {
+      logRequestFailure(
+        failureLogLevel,
+        `Write request failed for ${customKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return false;
+  }
+};
+var rnUploadAdapter = null;
+var noloUploadRequest = async (server, uploadConfig, state, signal) => {
+  const { file, metadata, customKey, userId } = uploadConfig;
+  try {
+    const isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+    const isRNFile = (f) => f && typeof f.uri === "string" && typeof f.name === "string" && typeof f.type === "string";
+    if (isReactNative && isRNFile(file)) {
+      if (!rnUploadAdapter) {
+        throw new Error(
+          "React Native upload adapter is not registered. Call initRNUploadAdapter() in the RN app entry before uploading files."
+        );
+      }
+      return await rnUploadAdapter(server, uploadConfig, state, signal);
+    }
+    const formData = new FormData();
+    if (isRNFile(file)) {
+      formData.append("file", {
+        uri: file.uri,
+        type: file.type,
+        name: file.name
+      });
+    } else {
+      formData.append("file", file);
+    }
+    formData.append("metadata", JSON.stringify(metadata));
+    formData.append("customKey", customKey);
+    if (userId) {
+      formData.append("userId", userId);
+    }
+    const response = await noloRequest(
+      server,
+      {
+        url: `${API_ENDPOINTS.DATABASE}/upload`,
+        method: "POST",
+        body: formData,
+        // Cast to any to avoid TS mismatch with Bun/DOM FormData
+        headers: {}
+        // 不设置 Content-Type，让浏览器自动处理 multipart/form-data
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      console.error(
+        `Upload request failed for ${customKey} on ${server}: HTTP ${response.status}`
+      );
+    }
+    return response.ok;
+  } catch (error) {
+    if (!isAbortError(error)) {
+      console.error(
+        `Upload request failed for ${customKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return false;
+  }
+};
+var syncWithServers = (servers, requestFn, errorMessage, ...requestArgs) => {
+  servers.forEach((server) => {
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => {
+      abortController.abort();
+    }, TIMEOUT);
+    requestFn(server, ...requestArgs, abortController.signal).then((success) => {
+      clearTimeout(timeoutId);
+      if (!success) {
+        console.warn(`${errorMessage} ${server}`);
+      }
+    }).catch((error) => {
+      clearTimeout(timeoutId);
+      if (!isAbortError(error)) {
+        console.error(
+          `Unexpected error during sync with ${server}: ${error.message || "Unknown error"}`
+        );
+      }
+    });
+  });
+};
+var noloDeleteRequest = async (server, dbKey, options, state, signal) => {
+  const { type = "single", force = false } = options;
+  try {
+    const queryParts = [];
+    if (type === "messages") queryParts.push("type=messages");
+    else if (type === "table") queryParts.push("type=table");
+    if (force) queryParts.push("force=true");
+    const query = queryParts.length ? `?${queryParts.join("&")}` : "";
+    const url = `${API_ENDPOINTS.DATABASE}/delete/${dbKey}${query}`;
+    const response = await noloRequest(
+      server,
+      {
+        url,
+        method: "DELETE",
+        keepalive: true
+      },
+      state,
+      signal
+    );
+    if (!response.ok) {
+      console.error(
+        `DELETE request failed for ${dbKey} on ${server}: HTTP ${response.status}`
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    if (!isAbortError(error)) {
+      console.error(
+        `DELETE request failed for ${dbKey} on ${server}: ${error.message || "Unknown error"}`
+      );
+    }
+    return false;
+  }
+};
+
+// packages/database/authority/ownerKey.ts
+var USER_OWNED_SECOND_SEGMENT_PREFIXES = /* @__PURE__ */ new Set([
+  "agent",
+  "dialog",
+  "page",
+  "doc",
+  "notification",
+  "email",
+  "meta",
+  "row",
+  "view",
+  "file",
+  "job"
+]);
+var PUBLIC_OWNER_SENTINELS = /* @__PURE__ */ new Set(["pub", "id", "stats", "index"]);
+var cleanSegment = (value) => {
+  const trimmed = asTrimmedString(value);
+  return trimmed.length > 0 ? trimmed : null;
+};
+var normalizeCandidateOwners = (candidateOwnerUserIds) => {
+  const out = [];
+  for (const candidate of candidateOwnerUserIds ?? []) {
+    const normalized = cleanSegment(candidate ?? void 0);
+    if (!normalized || PUBLIC_OWNER_SENTINELS.has(normalized)) continue;
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out.sort((left, right) => right.length - left.length);
+};
+var resolveCandidateOwnerFromKeyRemainder = (remainder, candidateOwnerUserIds) => {
+  const normalizedRemainder = cleanSegment(remainder);
+  if (!normalizedRemainder) return null;
+  for (const candidate of normalizeCandidateOwners(candidateOwnerUserIds)) {
+    if (normalizedRemainder === candidate || normalizedRemainder.startsWith(`${candidate}-`)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var parseOwnerUserIdFromDbKey = (dbKey, options = {}) => {
+  const normalized = cleanSegment(dbKey);
+  if (!normalized) return null;
+  const parts = normalized.split("-");
+  const [prefix] = parts;
+  if (!prefix) return null;
+  if (!USER_OWNED_SECOND_SEGMENT_PREFIXES.has(prefix)) {
+    if (prefix === "grant" && parts[1] === "agent" && parts.length >= 5) {
+      const ownerAndRest2 = normalized.slice(prefix.length + 1 + parts[1].length + 1);
+      const [owner2] = ownerAndRest2.split("-");
+      return cleanSegment(owner2);
+    }
+    return null;
+  }
+  if (parts[0] === "dialog" && parts[2] === "msg") {
+    return null;
+  }
+  const ownerAndRest = normalized.slice(prefix.length + 1);
+  const candidateOwner = resolveCandidateOwnerFromKeyRemainder(
+    ownerAndRest,
+    options.candidateOwnerUserIds
+  );
+  if (candidateOwner) return candidateOwner;
+  const [owner] = ownerAndRest.split("-");
+  const ownerUserId = cleanSegment(owner);
+  if (!ownerUserId) return null;
+  if (PUBLIC_OWNER_SENTINELS.has(ownerUserId)) return null;
+  return ownerUserId;
+};
+
+// packages/database/authority/userAuthorityRegistry.ts
+var normalizeAuthorityServerOrigin = (value) => {
+  const normalized = normalizeServerOrigin(value);
+  return /^https?:\/\//i.test(normalized) ? normalized : null;
+};
+var normalizeUserId = (value) => asOptionalTrimmedString(value) ?? null;
+var readEntryAuthorityServer = (entry) => {
+  if (typeof entry === "string") {
+    return normalizeAuthorityServerOrigin(entry);
+  }
+  if (!isRecord(entry)) {
+    return null;
+  }
+  return normalizeAuthorityServerOrigin(entry.authorityServer) ?? normalizeAuthorityServerOrigin(entry.homeServer) ?? normalizeAuthorityServerOrigin(entry.primaryServer);
+};
+var resolveUserAuthorityServer = ({
+  ownerUserId,
+  registry
+}) => {
+  const normalizedOwner = normalizeUserId(ownerUserId);
+  if (!normalizedOwner || !registry || typeof registry !== "object") {
+    return null;
+  }
+  return readEntryAuthorityServer(registry[normalizedOwner]);
+};
+
+// packages/database/authority/recordAuthority.ts
+var normalizeUserId2 = (value) => asOptionalTrimmedString(value) ?? null;
+var getRegistryOwnerCandidates = (registry) => isRecord(registry) ? Object.keys(registry) : [];
+var resolveRecordAuthority = ({
+  dbKey,
+  record,
+  currentUserId,
+  currentServer,
+  userAuthorityRegistry
+}) => {
+  const ownerUserId = parseOwnerUserIdFromDbKey(dbKey, {
+    candidateOwnerUserIds: [
+      normalizeUserId2(record?.userId),
+      normalizeUserId2(currentUserId),
+      ...getRegistryOwnerCandidates(userAuthorityRegistry)
+    ]
+  }) ?? normalizeUserId2(record?.userId);
+  const serverOrigin = normalizeAuthorityServerOrigin(record?.serverOrigin);
+  const explicitAuthority = normalizeAuthorityServerOrigin(record?.authorityServer);
+  const registryAuthority = resolveUserAuthorityServer({
+    ownerUserId,
+    registry: userAuthorityRegistry
+  });
+  const currentUserAuthority = ownerUserId && ownerUserId === normalizeUserId2(currentUserId) ? normalizeAuthorityServerOrigin(currentServer) : null;
+  return {
+    ownerUserId,
+    authorityServer: explicitAuthority ?? registryAuthority ?? currentUserAuthority ?? serverOrigin,
+    serverOrigin
+  };
+};
+
+// packages/database/actions/readResolution.ts
+var toComparableTimestamp = (data) => {
+  if (!data || typeof data !== "object") return 0;
+  const updatedAtMs = asOptionalPositiveFiniteNumber(
+    new Date(data.updatedAt).getTime()
+  );
+  if (updatedAtMs !== void 0) return updatedAtMs;
+  const createdAtMs = asOptionalPositiveFiniteNumber(
+    new Date(data.createdAt).getTime()
+  );
+  if (createdAtMs !== void 0) return createdAtMs;
+  return asOptionalPositiveFiniteNumber(Number(data?.meta?.createdAt)) ?? 0;
+};
+var partitionReadServers = ({
+  allServers,
+  preferredServerOrigin
+}) => {
+  const preferredServer = typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0 ? normalizeServerOrigin(preferredServerOrigin) : null;
+  const fallbackServers = preferredServer ? allServers.filter(
+    (server) => normalizeServerOrigin(server) !== preferredServer
+  ) : allServers;
+  return {
+    preferredServer,
+    fallbackServers,
+    orderedServersForLocalHit: preferredServer ? [preferredServer, ...fallbackServers] : fallbackServers
+  };
+};
+var compareRemoteRecordsByComparableTime = (left, right) => toComparableTimestamp(left) - toComparableTimestamp(right);
+var pickBestSettledRemoteRecord = ({
+  settledResults,
+  isBetterCandidate
+}) => {
+  const validResults = settledResults.map((result, index) => ({
+    data: result.status === "fulfilled" ? result.value : null,
+    index
+  })).filter((item) => item.data !== null && typeof item.data === "object");
+  if (validResults.length === 0) return null;
+  const latest2 = validResults.reduce(
+    (best, current2) => isBetterCandidate(current2.data, best.data) ? current2 : best
+  );
+  return { index: latest2.index, data: latest2.data };
+};
+var shouldReplaceLocalWithRemoteRecord = ({
+  localData,
+  remoteData,
+  isRemoteNewer
+}) => {
+  if (!remoteData || typeof remoteData !== "object") return false;
+  if (!localData || typeof localData !== "object") return true;
+  return isRemoteNewer(remoteData, localData);
+};
+var shouldReplicateLocalRecord = ({
+  localData,
+  remoteData,
+  remoteTargetCount
+}) => !!localData && !remoteData && remoteTargetCount > 0;
+var compactUniqueServers = (servers) => {
+  const out = [];
+  for (const server of servers) {
+    if (typeof server !== "string" || server.trim().length === 0) continue;
+    const normalized = normalizeServerOrigin(server);
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+};
+var planAuthorityReadServers = ({
+  allServers,
+  authorityServer,
+  serverOrigin
+}) => compactUniqueServers([authorityServer, serverOrigin, ...allServers]);
+
+// packages/database/fileRing.ts
+var fnv1a32 = (str) => {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash >>> 0;
+};
+var chooseServersByKey = (allServers, key, replicaCount) => {
+  if (!allServers.length || replicaCount <= 0) return [];
+  const uniqueServers = Array.from(new Set(allServers)).filter((s) => !!s);
+  if (uniqueServers.length === 0) return [];
+  const scored = uniqueServers.map((server) => ({
+    server,
+    score: fnv1a32(`${server}::${key}`)
+  }));
+  scored.sort((a, b) => a.score - b.score);
+  const limit = Math.min(replicaCount, scored.length);
+  return scored.slice(0, limit).map((item) => item.server);
+};
+
+// packages/database/tenantPlacement.ts
+var TENANT_REPLICA_COUNT = 2;
+var planServersForTenant = (allServers, currentServer, tenantId) => {
+  const uniqueServers = Array.from(new Set(allServers)).filter(Boolean);
+  if (!uniqueServers.length) return [];
+  const key = asOptionalTrimmedString(tenantId) ?? "default-tenant";
+  const fromRing = chooseServersByKey(
+    uniqueServers,
+    key,
+    TENANT_REPLICA_COUNT
+  );
+  const set2 = new Set(fromRing);
+  if (currentServer && uniqueServers.includes(currentServer)) {
+    set2.add(currentServer);
+  }
+  return Array.from(set2);
+};
+
+// packages/database/authority/deviceLocal.ts
+var DEVICE_LOCAL_OWNER_ID = "local";
+var DEVICE_LOCAL_DB_KEY_PREFIXES = [
+  "dialog-local-",
+  "agent-local-"
+];
+var clean = (value) => asOptionalTrimmedString(value) ?? null;
+var isDeviceLocalOwnerId = (userId) => clean(userId) === DEVICE_LOCAL_OWNER_ID;
+var resolveEffectiveSpaceActorId = (accountUserId) => {
+  const cleaned = clean(accountUserId);
+  if (!cleaned || isDeviceLocalOwnerId(cleaned)) {
+    return DEVICE_LOCAL_OWNER_ID;
+  }
+  return cleaned;
+};
+var isDeviceLocalSpaceMembership = (membership) => isDeviceLocalOwnerId(membership?.userId);
+var isDeviceLocalSpaceBody = (space) => isDeviceLocalOwnerId(space?.userId) || isDeviceLocalOwnerId(space?.ownerId);
+var isDeviceLocalDbKey = (dbKey) => {
+  const key = clean(dbKey);
+  if (!key) return false;
+  for (const prefix of DEVICE_LOCAL_DB_KEY_PREFIXES) {
+    if (key.startsWith(prefix)) return true;
+  }
+  return parseOwnerUserIdFromDbKey(key, {
+    candidateOwnerUserIds: [DEVICE_LOCAL_OWNER_ID]
+  }) === DEVICE_LOCAL_OWNER_ID;
+};
+var resolveRecordOwnerUserId = (record) => {
+  if (!record) return null;
+  const explicit = clean(record.userId);
+  if (explicit) return explicit;
+  if (isDeviceLocalDbKey(record.dbKey) || isDeviceLocalDbKey(record.id)) {
+    return DEVICE_LOCAL_OWNER_ID;
+  }
+  const fromKey = parseOwnerUserIdFromDbKey(clean(record.dbKey) ?? "", {
+    candidateOwnerUserIds: [DEVICE_LOCAL_OWNER_ID]
+  }) ?? parseOwnerUserIdFromDbKey(clean(record.id) ?? "", {
+    candidateOwnerUserIds: [DEVICE_LOCAL_OWNER_ID]
+  });
+  return fromKey;
+};
+
+// packages/database/actions/replication.ts
+var isReadonlyPublicRecordKey = (dbKey) => dbKey.startsWith("agent-pub-");
+var normalizeCurrentUserId = (state) => {
+  const userId = state?.auth?.currentUser?.userId;
+  return asOptionalTrimmedString(userId) ?? null;
+};
+var resolveReplicationServers = (currentServer, syncServers, preferredServerOrigin) => getAllServers(currentServer, syncServers, preferredServerOrigin);
+var resolveAuthorityReplicationServers = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  record,
+  state
+}) => {
+  const allServers = resolveReplicationServers(
+    currentServer,
+    syncServers,
+    preferredServerOrigin
+  );
+  const authority = resolveRecordAuthority({
+    dbKey,
+    record,
+    currentUserId: state?.auth?.currentUser?.userId,
+    currentServer,
+    userAuthorityRegistry: state?.settings?.userAuthorityRegistry ?? state?.auth?.currentUser?.authorityRegistry
+  });
+  if (isDeviceLocalOwnerId(authority.ownerUserId) || isDeviceLocalOwnerId(record?.userId) || isDeviceLocalDbKey(dbKey)) {
+    return [];
+  }
+  return planAuthorityReadServers({
+    allServers,
+    authorityServer: preferredServerOrigin ?? authority.authorityServer,
+    serverOrigin: authority.serverOrigin
+  });
+};
+var scheduleWriteReplication = (servers, request, state) => {
+  if (servers.length === 0) return;
+  Promise.resolve().then(async () => {
+    const [primaryServer, ...backupServers] = servers;
+    const primarySucceeded = await noloWriteRequest(primaryServer, request, state);
+    if (!primarySucceeded) {
+      console.warn(`Primary write sync failed for ${request.customKey} on ${primaryServer}`);
+    }
+    if (backupServers.length === 0) {
+      return;
+    }
+    syncWithServers(
+      backupServers,
+      (server, requestConfig, requestState, signal) => noloWriteRequest(server, requestConfig, requestState, signal, {
+        failureLogLevel: "info"
+      }),
+      `Backup write sync failed for ${request.customKey} on`,
+      request,
+      state
+    );
+  });
+};
+var resolveTenantReplicationServers = ({
+  currentServer,
+  syncServers,
+  tenantId
+}) => {
+  const allServers = resolveReplicationServers(currentServer, syncServers);
+  if (allServers.length === 0) {
+    return [];
+  }
+  return planServersForTenant(allServers, currentServer, tenantId);
+};
+var resolveUploadReplicationServers = ({
+  currentServer,
+  syncServers,
+  tenantId,
+  uploadConfig,
+  state
+}) => {
+  const allServers = resolveReplicationServers(currentServer, syncServers);
+  const authority = resolveRecordAuthority({
+    dbKey: uploadConfig.customKey,
+    record: uploadConfig.metadata,
+    currentUserId: state?.auth?.currentUser?.userId,
+    currentServer,
+    userAuthorityRegistry: state?.settings?.userAuthorityRegistry ?? state?.auth?.currentUser?.authorityRegistry
+  });
+  if (authority.ownerUserId || authority.authorityServer) {
+    return planAuthorityReadServers({
+      allServers,
+      authorityServer: authority.authorityServer,
+      serverOrigin: authority.serverOrigin
+    });
+  }
+  return resolveTenantReplicationServers({
+    currentServer,
+    syncServers,
+    tenantId
+  });
+};
+var scheduleExistingRecordReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  localData,
+  state
+}) => {
+  if (isReadonlyPublicRecordKey(dbKey)) {
+    return [];
+  }
+  const currentUserId = normalizeCurrentUserId(state);
+  const authority = resolveRecordAuthority({
+    dbKey,
+    record: localData,
+    currentUserId,
+    currentServer,
+    userAuthorityRegistry: state?.settings?.userAuthorityRegistry ?? state?.auth?.currentUser?.authorityRegistry
+  });
+  if (authority.ownerUserId && currentUserId && authority.ownerUserId !== currentUserId) {
+    return [];
+  }
+  const servers = resolveAuthorityReplicationServers({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    record: localData,
+    state
+  });
+  if (servers.length === 0) {
+    return [];
+  }
+  scheduleWriteReplication(
+    servers,
+    {
+      data: localData,
+      customKey: dbKey,
+      userId: typeof localData?.userId === "string" ? localData.userId : state?.auth?.currentUser?.userId
+    },
+    state
+  );
+  return servers;
+};
+var schedulePatchReplication = ({
+  servers,
+  dbKey,
+  changes,
+  state,
+  preferredServerOrigin
+}) => {
+  if (servers.length === 0) return;
+  Promise.resolve().then(async () => {
+    const primaryServer = typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0 ? normalizeServerOrigin(preferredServerOrigin) : servers[0];
+    const backupServers = servers.filter(
+      (server) => normalizeServerOrigin(server) !== primaryServer
+    );
+    const primarySucceeded = await noloPatchRequest(primaryServer, dbKey, changes, state, void 0, {
+      failureLogLevel: "warn"
+    });
+    if (!primarySucceeded) {
+      console.warn(`Primary patch sync failed for ${dbKey} on ${primaryServer}`);
+    }
+    if (backupServers.length > 0) {
+      syncWithServers(
+        backupServers,
+        (server, targetDbKey, nextChanges, requestState, signal) => noloPatchRequest(server, targetDbKey, nextChanges, requestState, signal, {
+          failureLogLevel: "info"
+        }),
+        `Backup patch sync failed for ${dbKey} on`,
+        dbKey,
+        changes,
+        state
+      );
+    }
+  });
+};
+var scheduleConfiguredPatchReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  changes,
+  state
+}) => {
+  const servers = resolveAuthorityReplicationServers({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    record: changes,
+    state
+  });
+  if (servers.length === 0) {
+    return [];
+  }
+  schedulePatchReplication({
+    servers,
+    dbKey,
+    changes,
+    state,
+    preferredServerOrigin
+  });
+  return servers;
+};
+var scheduleUploadReplication = ({
+  currentServer,
+  syncServers,
+  tenantId,
+  uploadConfig,
+  state,
+  excludeServers = []
+}) => {
+  const servers = resolveUploadReplicationServers({
+    currentServer,
+    syncServers,
+    tenantId,
+    uploadConfig,
+    state
+  });
+  const excluded = new Set(
+    excludeServers.filter((server) => typeof server === "string").map((server) => normalizeServerOrigin(server))
+  );
+  const remainingServers = servers.filter(
+    (server) => !excluded.has(normalizeServerOrigin(server))
+  );
+  if (remainingServers.length === 0) {
+    return [];
+  }
+  Promise.resolve().then(() => {
+    syncWithServers(
+      remainingServers,
+      noloUploadRequest,
+      `Upload sync failed for ${uploadConfig.customKey} on`,
+      uploadConfig,
+      state
+    );
+  });
+  return remainingServers;
+};
+var uploadToCurrentServer = async ({
+  currentServer,
+  uploadConfig,
+  state
+}) => {
+  if (!currentServer) {
+    return false;
+  }
+  return noloUploadRequest(currentServer, uploadConfig, state);
+};
+var deleteFromReplicationServers = async ({
+  servers,
+  dbKey,
+  deleteOptions = { type: "single" },
+  state,
+  preferredServerOrigin
+}) => {
+  if (!servers.length) {
+    return { succeeded: [], failed: [] };
+  }
+  const preferredServer = typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0 ? normalizeServerOrigin(preferredServerOrigin) : null;
+  const remainingServers = preferredServer ? servers.filter((server) => normalizeServerOrigin(server) !== preferredServer) : servers;
+  const succeeded = [];
+  const failed = [];
+  if (preferredServer) {
+    const ok = await noloDeleteRequest(preferredServer, dbKey, deleteOptions, state);
+    if (ok) {
+      succeeded.push(preferredServer);
+    } else {
+      failed.push(preferredServer);
+    }
+  }
+  if (remainingServers.length > 0) {
+    const results = await Promise.all(
+      remainingServers.map(async (server) => ({
+        server,
+        ok: await noloDeleteRequest(server, dbKey, deleteOptions, state)
+      }))
+    );
+    results.forEach(({ server, ok }) => {
+      if (ok) succeeded.push(server);
+      else failed.push(server);
+    });
+  }
+  return { succeeded, failed };
+};
+var scheduleDeleteReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  deleteOptions,
+  state,
+  onResult,
+  onError
+}) => {
+  const servers = resolveAuthorityReplicationServers({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state
+  });
+  if (servers.length === 0) {
+    return [];
+  }
+  void Promise.resolve().then(
+    () => deleteFromReplicationServers({
+      servers,
+      dbKey,
+      deleteOptions,
+      state,
+      preferredServerOrigin
+    })
+  ).then((result) => {
+    onResult?.(result);
+  }).catch((error) => {
+    onError?.(error);
+  });
+  return servers;
+};
+
+export {
+  createSelector,
+  createAction,
+  createAsyncThunk,
+  asyncThunkCreator,
+  buildCreateSlice,
+  createEntityAdapter,
+  selectIdentityUserId,
+  selectIdentityToken,
+  selectIdentityUser,
+  selectRuntimeSnapshot,
+  selectRuntimeCurrentServer,
+  getRuntimeServerContext,
+  noloWriteRequest,
+  noloDeleteRequest,
+  parseOwnerUserIdFromDbKey,
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalOwnerId,
+  resolveEffectiveSpaceActorId,
+  isDeviceLocalSpaceMembership,
+  isDeviceLocalSpaceBody,
+  resolveRecordOwnerUserId,
+  resolveRecordAuthority,
+  partitionReadServers,
+  compareRemoteRecordsByComparableTime,
+  pickBestSettledRemoteRecord,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord,
+  planAuthorityReadServers,
+  resolveReplicationServers,
+  resolveAuthorityReplicationServers,
+  scheduleWriteReplication,
+  resolveUploadReplicationServers,
+  scheduleExistingRecordReplication,
+  scheduleConfiguredPatchReplication,
+  scheduleUploadReplication,
+  uploadToCurrentServer,
+  scheduleDeleteReplication
+};