nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.3

package/{chunk-WIWM4FE3.js → chunk-IJERIUXS.js}

@@ -1,36 +1,12 @@
 import {
-  getAllServers,
-  getIsDesktopApp,
-  isAbortError
-} from "./chunk-QOKAKDPE.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";
+  isAbortError
+} from "./chunk-7DPNBQSV.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;
@@ -2171,97 +2147,6 @@ 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) => {
@@ -2355,7 +2240,38 @@ var noloWriteRequest = async (server, writeConfig, state, signal, options) => {
   }
 };
 var rnUploadAdapter = null;
-var noloUploadRequest = async (server, uploadConfig, state, signal) => {
+var xhrUploadRequest = (url, formData, state, onProgress, signal) => new Promise((resolve, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Upload aborted", "AbortError"));
+    return;
+  }
+  const xhr = new XMLHttpRequest();
+  xhr.open("POST", url);
+  const token = selectIdentityToken(state) ?? null;
+  if (token) {
+    xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+  }
+  const onAbortSignal = () => xhr.abort();
+  signal?.addEventListener("abort", onAbortSignal, { once: true });
+  const cleanup = () => signal?.removeEventListener("abort", onAbortSignal);
+  xhr.upload.onprogress = (event) => {
+    if (event.lengthComputable) onProgress(event.loaded, event.total);
+  };
+  xhr.onload = () => {
+    cleanup();
+    resolve({ ok: xhr.status >= 200 && xhr.status < 300, status: xhr.status });
+  };
+  xhr.onerror = () => {
+    cleanup();
+    reject(new Error("Network error during upload"));
+  };
+  xhr.onabort = () => {
+    cleanup();
+    reject(new DOMException("Upload aborted", "AbortError"));
+  };
+  xhr.send(formData);
+});
+var noloUploadRequest = async (server, uploadConfig, state, signal, onProgress) => {
   const { file, metadata, customKey, userId } = uploadConfig;
   try {
     const isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
@@ -2383,6 +2299,21 @@ var noloUploadRequest = async (server, uploadConfig, state, signal) => {
     if (userId) {
       formData.append("userId", userId);
     }
+    if (onProgress && typeof XMLHttpRequest !== "undefined") {
+      const result = await xhrUploadRequest(
+        server + `${API_ENDPOINTS.DATABASE}/upload`,
+        formData,
+        state,
+        onProgress,
+        signal
+      );
+      if (!result.ok) {
+        console.error(
+          `Upload request failed for ${customKey} on ${server}: HTTP ${result.status}`
+        );
+      }
+      return result.ok;
+    }
     const response = await noloRequest(
       server,
       {
@@ -2468,606 +2399,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,
@@ -3075,33 +2406,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
 };