nolo-cli 0.107.0-alpha.4 → 0.107.0

package/{chunk-UKWGR5SS.js → chunk-VY6VFGKR.js}

@@ -1,36 +1,12 @@
 import {
-  getAllServers,
-  getIsDesktopApp,
   isAbortError
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-HIM3FCLF.js";
 import {
-  selectIdentityToken,
-  selectIdentityUser,
-  selectIdentityUserId
+  selectIdentityToken
 } from "./chunk-SEJ5OS6F.js";
 import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  asOptionalPositiveFiniteNumber
-} from "./chunk-U6VC4MU4.js";
-import {
-  API_ENDPOINTS,
-  SERVERS,
-  normalizeKnownServerOrigin
+  API_ENDPOINTS
 } from "./chunk-LCBAMY2M.js";
-import {
-  isLocalServerUrl
-} from "./chunk-4SN6J65J.js";
-import {
-  normalizeServerOrigin
-} from "./chunk-CF7PE763.js";
-import {
-  asOptionalTrimmedString
-} from "./chunk-G3SUCT4W.js";
 
 // node_modules/reselect/dist/reselect.mjs
 var CACHE_SIZE_CHECK_THRESHOLD = 1e3;
@@ -941,7 +917,7 @@ var objectTraps = {
       const currentState = current2?.[DRAFT_STATE];
       if (currentState && currentState.base_ === value) {
         state.copy_[prop] = value;
-        state.assigned_.set(prop, false);
+        state.assigned_.delete(prop);
         return true;
       }
       if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
@@ -1268,9 +1244,7 @@ var createDraftSafeSelectorCreator = (...args) => {
     const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);
     Object.assign(wrappedSelector, selector);
     return wrappedSelector;
-  }, {
-    withTypes: () => createDraftSafeSelector2
-  });
+  }, { withTypes: () => createDraftSafeSelector2 });
   return createDraftSafeSelector2;
 };
 var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(weakMapMemoize);
@@ -1279,11 +1253,7 @@ var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOO
   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;
-  };
-};
+typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__;
 var hasMatchFunction = (v) => {
   return v && typeof v.match === "function";
 };
@@ -1291,18 +1261,12 @@ 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");
-      }
+      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
-        }
+        ..."meta" in prepared && { meta: prepared.meta },
+        ..."error" in prepared && { error: prepared.error }
       };
     }
     return {
@@ -1319,7 +1283,12 @@ function isFSA(action) {
   return isAction(action) && Object.keys(action).every(isValidKey);
 }
 function isValidKey(key) {
-  return ["type", "payload", "error", "meta"].indexOf(key) > -1;
+  return [
+    "type",
+    "payload",
+    "error",
+    "meta"
+  ].indexOf(key) > -1;
 }
 function freezeDraftable(val) {
   return isDraftable(val) ? produce(val, () => {
@@ -1336,28 +1305,18 @@ function executeReducerBuilderCallback(builderCallback) {
   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`");
-        }
+        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}'`);
-      }
+      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;
     },
     addAsyncThunk(asyncThunk, reducers) {
       if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
-        }
+        if (defaultCaseReducer) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
       }
       if (reducers.pending) actionsMap[asyncThunk.pending.type] = reducers.pending;
       if (reducers.rejected) actionsMap[asyncThunk.rejected.type] = reducers.rejected;
@@ -1370,9 +1329,7 @@ function executeReducerBuilderCallback(builderCallback) {
     },
     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`");
-        }
+        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,
@@ -1382,66 +1339,52 @@ function executeReducerBuilderCallback(builderCallback) {
     },
     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");
-        }
+        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];
+  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");
-    }
+    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 {
+  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];
-    }
+    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;
-          }
+          const result = caseReducer(previousState, 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");
+            if (previousState === null) return previousState;
+            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(9) : "A case reducer on a non-draftable value must not return undefined");
           }
           return result;
-        } else {
-          return produce(previousState, (draft) => {
-            return caseReducer(draft, action);
-          });
-        }
+        } else return produce(previousState, (draft) => {
+          return caseReducer(draft, action);
+        });
       }
       return previousState;
     }, state);
@@ -1450,11 +1393,8 @@ function createReducer(initialState, mapOrBuilderCallback) {
   return reducer;
 }
 var matches = (matcher, action) => {
-  if (hasMatchFunction(matcher)) {
-    return matcher.match(action);
-  } else {
-    return matcher(action);
-  }
+  if (hasMatchFunction(matcher)) return matcher.match(action);
+  else return matcher(action);
 };
 function isAnyOf(...matchers) {
   return (action) => {
@@ -1465,51 +1405,40 @@ var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXI
 var nanoid = (size = 21) => {
   let id = "";
   let i = size;
-  while (i--) {
-    id += urlAlphabet[Math.random() * 64 | 0];
-  }
+  while (i--) id += urlAlphabet[Math.random() * 64 | 0];
   return id;
 };
-var commonProperties = ["name", "message", "stack", "code"];
+var commonProperties = [
+  "name",
+  "message",
+  "stack",
+  "code"
+];
 var RejectWithValue = class {
+  payload;
+  meta;
+  _type;
   constructor(payload, meta) {
     this.payload = payload;
     this.meta = meta;
   }
+};
+var FulfillWithMeta = class {
   payload;
   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;
   }
-  payload;
-  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];
-      }
-    }
+    for (const property of commonProperties) if (typeof value[property] === "string") simpleError[property] = value[property];
     return simpleError;
   }
-  return {
-    message: String(value)
-  };
+  return { message: String(value) };
 };
 var externalAbortMessage = "External signal was aborted";
 var createAsyncThunk = /* @__PURE__ */ (() => {
@@ -1539,15 +1468,13 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
         ...meta || {},
         arg,
         requestId,
-        rejectedWithValue: !!payload,
+        rejectedWithValue: payload !== void 0,
         requestStatus: "rejected",
         aborted: error?.name === "AbortError",
         condition: error?.name === "ConditionError"
       }
     }));
-    function actionCreator(arg, {
-      signal
-    } = {}) {
+    function actionCreator(arg, { signal } = {}) {
       return (dispatch, getState, extra) => {
         const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
         const abortController = new AbortController();
@@ -1558,13 +1485,8 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
           abortController.abort();
         }
         if (signal) {
-          if (signal.aborted) {
-            abort(externalAbortMessage);
-          } else {
-            signal.addEventListener("abort", () => abort(externalAbortMessage), {
-              once: true
-            });
-          }
+          if (signal.aborted) abort(externalAbortMessage);
+          else signal.addEventListener("abort", () => abort(externalAbortMessage), { once: true });
         }
         const promise = async function() {
           let finalAction;
@@ -1573,15 +1495,15 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
               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."
-              };
-            }
+            if (isThenable(conditionResult)) conditionResult = await conditionResult;
+            if (conditionResult === false) throw {
+              name: "ConditionError",
+              message: "Aborted due to condition callback returning false."
+            };
+            if (abortController.signal.aborted) throw {
+              name: "AbortError",
+              message: abortReason || "Aborted"
+            };
             const abortedPromise = new Promise((_, reject) => {
               abortHandler = () => {
                 reject({
@@ -1589,9 +1511,7 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
                   message: abortReason || "Aborted"
                 });
               };
-              abortController.signal.addEventListener("abort", abortHandler, {
-                once: true
-              });
+              abortController.signal.addEventListener("abort", abortHandler, { once: true });
             });
             dispatch(pending(requestId, arg, options?.getPendingMeta?.({
               requestId,
@@ -1614,25 +1534,16 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
                 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);
-              }
+              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);
+            if (abortHandler) abortController.signal.removeEventListener("abort", abortHandler);
           }
+          if (!(options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition)) dispatch(finalAction);
           return finalAction;
         }();
         return Object.assign(promise, {
@@ -1657,40 +1568,25 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
   return createAsyncThunk2;
 })();
 function unwrapResult(action) {
-  if (action.meta && action.meta.rejectedWithValue) {
-    throw action.payload;
-  }
-  if (action.error) {
-    throw action.error;
-  }
+  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
-};
+var asyncThunkCreator = { [asyncThunkSymbol]: createAsyncThunk };
 function getType(slice, actionKey) {
   return `${slice}/${actionKey}`;
 }
-function buildCreateSlice({
-  creators
-} = {}) {
+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");
-    }
+  return function createSlice(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`");
-      }
+      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);
@@ -1703,12 +1599,8 @@ function buildCreateSlice({
     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);
-        }
+        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;
       },
@@ -1735,17 +1627,12 @@ function buildCreateSlice({
         type: getType(name, reducerName),
         createNotation: typeof options.reducers === "function"
       };
-      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
-        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
-      } else {
-        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
-      }
+      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");
-        }
+        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 = {
@@ -1753,18 +1640,10 @@ function buildCreateSlice({
         ...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);
-        }
+        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;
@@ -1783,21 +1662,15 @@ function buildCreateSlice({
       function selectSlice(state) {
         let sliceState = state[reducerPath2];
         if (typeof sliceState === "undefined") {
-          if (injected) {
-            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, 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");
-          }
+          if (injected) sliceState = getOrInsertComputed(injectedStateCache, selectSlice, 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, () => {
+        return getOrInsertComputed(getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap()), selectState, () => {
           const map = {};
-          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
-            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
-          }
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
           return map;
         });
       }
@@ -1817,10 +1690,7 @@ function buildCreateSlice({
       caseReducers: context.sliceCaseReducersByName,
       getInitialState,
       ...makeSelectorProps(reducerPath),
-      injectInto(injectable, {
-        reducerPath: pathOpt,
-        ...config
-      } = {}) {
+      injectInto(injectable, { reducerPath: pathOpt, ...config } = {}) {
         const newReducerPath = pathOpt ?? reducerPath;
         injectable.inject({
           reducerPath: newReducerPath,
@@ -1839,11 +1709,8 @@ 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");
-      }
+      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);
   }
@@ -1861,16 +1728,9 @@ function buildReducerCreators() {
   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 */
-      });
+      return Object.assign({ [caseReducer.name](...args) {
+        return caseReducer(...args);
+      } }[caseReducer.name], { _reducerDefinitionType: "reducer" });
     },
     preparedReducer(prepare, reducer) {
       return {
@@ -1882,22 +1742,14 @@ function buildReducerCreators() {
     asyncThunk
   };
 }
-function handleNormalReducerDefinition({
-  type,
-  reducerName,
-  createNotation
-}, maybeReducerWithPrepare, context) {
+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.");
-    }
+    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;
-  }
+  } else caseReducer = maybeReducerWithPrepare;
   context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
 }
 function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
@@ -1906,43 +1758,23 @@ function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
 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;
+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);
-  }
+  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
+    fulfilled: fulfilled || noop$1,
+    pending: pending || noop$1,
+    rejected: rejected || noop$1,
+    settled: settled || noop$1
   });
 }
-function noop() {
+function noop$1() {
 }
 function getInitialEntityState() {
   return {
@@ -1955,30 +1787,24 @@ function createInitialStateFactory(stateAdapter) {
     const state = Object.assign(getInitialEntityState(), additionalState);
     return entities ? stateAdapter.setAll(state, entities) : state;
   }
-  return {
-    getInitialState
-  };
+  return { getInitialState };
 }
 function createSelectorsFactory() {
   function getSelectors(selectState, options = {}) {
-    const {
-      createSelector: createSelector2 = createDraftSafeSelector
-    } = 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)
-      };
-    }
+    if (!selectState) return {
+      selectIds,
+      selectEntities,
+      selectAll,
+      selectTotal,
+      selectById: createSelector2(selectEntities, selectId, selectById)
+    };
     const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
     return {
       selectIds: createSelector2(selectState, selectIds),
@@ -1988,9 +1814,7 @@ function createSelectorsFactory() {
       selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
     };
   }
-  return {
-    getSelectors
-  };
+  return { getSelectors };
 }
 var isDraftTyped = isDraft;
 function createSingleArgumentStateOperator(mutator) {
@@ -2005,11 +1829,8 @@ function createStateOperator(mutator) {
       return isFSA(arg2);
     }
     const runMutator = (draft) => {
-      if (isPayloadActionArgument(arg)) {
-        mutator(arg.payload, draft);
-      } else {
-        mutator(arg, draft);
-      }
+      if (isPayloadActionArgument(arg)) mutator(arg.payload, draft);
+      else mutator(arg, draft);
     };
     if (isDraftTyped(state)) {
       runMutator(state);
@@ -2020,15 +1841,11 @@ function createStateOperator(mutator) {
 }
 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());
-  }
+  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);
-  }
+  if (!Array.isArray(entities)) entities = Object.values(entities);
   return entities;
 }
 function getCurrent(value) {
@@ -2043,52 +1860,46 @@ function splitAddedUpdatedEntities(newEntities, selectId, state) {
   const updated = [];
   for (const entity of newEntities) {
     const id = selectIdValue(entity, selectId);
-    if (existingIds.has(id) || addedIds.has(id)) {
-      updated.push({
-        id,
-        changes: entity
-      });
-    } else {
+    if (existingIds.has(id) || addedIds.has(id)) updated.push({
+      id,
+      changes: entity
+    });
+    else {
       addedIds.add(id);
       added.push(entity);
     }
   }
-  return [added, updated, existingIdsArray];
+  return [
+    added,
+    updated,
+    existingIdsArray
+  ];
 }
 function createUnsortedStateAdapter(selectId) {
   function addOneMutably(entity, state) {
     const key = selectIdValue(entity, selectId);
-    if (key in state.entities) {
-      return;
-    }
+    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);
-    }
+    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);
-    }
-    ;
+    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);
-    }
+    for (const entity of newEntities) setOneMutably(entity, state);
   }
   function setAllMutably(newEntities, state) {
     newEntities = ensureEntitiesArray(newEntities);
     state.ids = [];
     state.entities = {};
-    addManyMutably(newEntities, state);
+    setManyMutably(newEntities, state);
   }
   function removeOneMutably(key, state) {
     return removeManyMutably([key], state);
@@ -2101,9 +1912,7 @@ function createUnsortedStateAdapter(selectId) {
         didMutate = true;
       }
     });
-    if (didMutate) {
-      state.ids = state.ids.filter((id) => id in state.entities);
-    }
+    if (didMutate) state.ids = state.ids.filter((id) => id in state.entities);
   }
   function removeAllMutably(state) {
     Object.assign(state, {
@@ -2112,18 +1921,15 @@ function createUnsortedStateAdapter(selectId) {
     });
   }
   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 original2 = state.entities[update.id];
+    if (original2 === void 0) return false;
+    const updated = Object.assign({}, original2, 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;
   }
@@ -2134,25 +1940,17 @@ function createUnsortedStateAdapter(selectId) {
     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
-          }
-        };
-      }
+      if (update.id in state.entities) updatesPerEntity[update.id] = {
+        id: update.id,
+        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));
-      }
+    if (updates.length > 0) {
+      if (updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0) state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
     }
   }
   function upsertOneMutably(entity, state) {
@@ -2184,12 +1982,8 @@ function findInsertIndex(sortedItems, item, comparisonFunction) {
   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;
-    }
+    if (comparisonFunction(item, currentItem) >= 0) lowIndex = middleIndex + 1;
+    else highIndex = middleIndex;
   }
   return lowIndex;
 }
@@ -2199,11 +1993,7 @@ function insert(sortedItems, item, comparisonFunction) {
   return sortedItems;
 }
 function createSortedStateAdapter(selectId, comparer) {
-  const {
-    removeOne,
-    removeMany,
-    removeAll
-  } = createUnsortedStateAdapter(selectId);
+  const { removeOne, removeMany, removeAll } = createUnsortedStateAdapter(selectId);
   function addOneMutably(entity, state) {
     return addManyMutably([entity], state);
   }
@@ -2217,9 +2007,7 @@ function createSortedStateAdapter(selectId, comparer) {
       if (notAdded) addedKeys.add(modelId);
       return !existingKeys.has(modelId) && notAdded;
     });
-    if (models.length !== 0) {
-      mergeFunction(state, models);
-    }
+    if (models.length !== 0) mergeFunction(state, models);
   }
   function setOneMutably(entity, state) {
     return setManyMutably([entity], state);
@@ -2241,7 +2029,7 @@ function createSortedStateAdapter(selectId, comparer) {
     newEntities = ensureEntitiesArray(newEntities);
     state.entities = {};
     state.ids = [];
-    addManyMutably(newEntities, state, []);
+    setManyMutably(newEntities, state);
   }
   function updateOneMutably(update, state) {
     return updateManyMutably([update], state);
@@ -2249,11 +2037,17 @@ function createSortedStateAdapter(selectId, comparer) {
   function updateManyMutably(updates, state) {
     let appliedUpdates = false;
     let replacedIds = false;
-    for (let update of updates) {
-      const entity = state.entities[update.id];
-      if (!entity) {
-        continue;
+    const updatesPerEntity = {};
+    for (const update of updates) if (update.id in state.entities) updatesPerEntity[update.id] = {
+      id: update.id,
+      changes: {
+        ...updatesPerEntity[update.id]?.changes,
+        ...update.changes
       }
+    };
+    for (const update of Object.values(updatesPerEntity)) {
+      const entity = state.entities[update.id];
+      if (!entity) continue;
       appliedUpdates = true;
       Object.assign(entity, update.changes);
       const newId = selectId(entity);
@@ -2265,66 +2059,45 @@ function createSortedStateAdapter(selectId, comparer) {
         state.entities[newId] = entity;
       }
     }
-    if (appliedUpdates) {
-      mergeFunction(state, [], appliedUpdates, replacedIds);
-    }
+    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 (added.length) {
-      addManyMutably(added, state, existingIdsArray);
-    }
-    if (updated.length) {
-      updateManyMutably(updated, state);
-    }
+    if (added.length) addManyMutably(added, state, existingIdsArray);
+    if (updated.length) updateManyMutably(updated, state);
   }
   function areArraysEqual(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
+    if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
-      if (a[i] === b[i]) {
-        continue;
-      }
+      if (a[i] === b[i]) continue;
       return false;
     }
     return true;
   }
-  const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
+  function 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);
-    }
+    if (replacedIds) ids = new Set(currentIds);
     let sortedEntities = [];
     for (const id of ids) {
       const entity = currentEntities[id];
-      if (entity) {
-        sortedEntities.push(entity);
-      }
+      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);
+      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;
-    }
-  };
+    if (!areArraysEqual(currentIds, newSortedIds)) state.ids = newSortedIds;
+  }
   return {
     removeOne,
     removeMany,
@@ -2341,10 +2114,7 @@ function createSortedStateAdapter(selectId, comparer) {
   };
 }
 function createEntityAdapter(options = {}) {
-  const {
-    selectId,
-    sortComparer
-  } = {
+  const { selectId, sortComparer } = {
     sortComparer: false,
     selectId: (instance) => instance.id,
     ...options
@@ -2367,112 +2137,16 @@ var taskCancelled = `task-${cancelled}`;
 var taskCompleted = `task-${completed}`;
 var listenerCancelled = `${listener}-${cancelled}`;
 var listenerCompleted = `${listener}-${completed}`;
-var {
-  assign
-} = Object;
+var { assign } = Object;
 var alm = "listenerMiddleware";
-var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
-  withTypes: () => addListener
-});
+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 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/app/stateViews/runtime.ts
-var selectCurrentToken = (state) => {
-  const token = selectIdentityToken(state);
-  return typeof token === "string" ? token : void 0;
-};
-var selectCurrentUserId = (state) => {
-  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 = selectIdentityUser(state)?.authorityRegistry;
-  if (userRegistry && typeof userRegistry === "object") {
-    return userRegistry;
-  }
-  return void 0;
-};
-
 // packages/database/requests.ts
 var TIMEOUT = 5e3;
 var logRequestFailure = (level, message) => {
@@ -2679,606 +2353,6 @@ var noloDeleteRequest = async (server, dbKey, options, state, signal) => {
   }
 };
 
-// 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/core/fnv1a32.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 fnv1a32Hex = (str) => fnv1a32(str).toString(16).padStart(8, "0");
-
-// packages/database/fileRing.ts
-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 = selectIdentityUserId(state);
-  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: selectIdentityUserId(state),
-    currentServer,
-    userAuthorityRegistry: state?.settings?.userAuthorityRegistry ?? selectIdentityUser(state)?.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: selectIdentityUserId(state),
-    currentServer,
-    userAuthorityRegistry: state?.settings?.userAuthorityRegistry ?? selectIdentityUser(state)?.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 ?? selectIdentityUser(state)?.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 : selectIdentityUserId(state)
-    },
-    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,
@@ -3286,33 +2360,9 @@ export {
   asyncThunkCreator,
   buildCreateSlice,
   createEntityAdapter,
-  selectRuntimeSnapshot,
-  selectRuntimeCurrentServer,
-  getRuntimeServerContext,
+  noloPatchRequest,
   noloWriteRequest,
-  noloDeleteRequest,
-  fnv1a32Hex,
-  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
+  noloUploadRequest,
+  syncWithServers,
+  noloDeleteRequest
 };