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

package/chunk-4YRTZIVN.js

@@ -0,0 +1,871 @@
+import {
+  fnv1a32
+} from "./chunk-UEILX4EV.js";
+import {
+  createSelector,
+  noloDeleteRequest,
+  noloPatchRequest,
+  noloUploadRequest,
+  noloWriteRequest,
+  syncWithServers
+} from "./chunk-IJERIUXS.js";
+import {
+  getAllServers,
+  getIsDesktopApp
+} from "./chunk-6Q7UTJKR.js";
+import {
+  selectIdentityToken,
+  selectIdentityUser,
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  SERVERS,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  isLocalServerUrl
+} from "./chunk-4SN6J65J.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// 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/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 latest = validResults.reduce(
+    (best, current) => isBetterCandidate(current.data, best.data) ? current : best
+  );
+  return { index: latest.index, data: latest.data };
+};
+var shouldReplaceLocalWithRemoteRecord = ({
+  localData,
+  remoteData,
+  isRemoteNewer
+}) => {
+  if (!remoteData || typeof remoteData !== "object") return false;
+  if (!localData || typeof localData !== "object") return true;
+  return isRemoteNewer(remoteData, localData);
+};
+var shouldReplicateLocalRecord = ({
+  localData,
+  remoteData,
+  remoteTargetCount
+}) => !!localData && !remoteData && remoteTargetCount > 0;
+var compactUniqueServers = (servers) => {
+  const out = [];
+  for (const server of servers) {
+    if (typeof server !== "string" || server.trim().length === 0) continue;
+    const normalized = normalizeServerOrigin(server);
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+};
+var planAuthorityReadServers = ({
+  allServers,
+  authorityServer,
+  serverOrigin
+}) => compactUniqueServers([authorityServer, serverOrigin, ...allServers]);
+
+// packages/database/fileRing.ts
+var 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 set = new Set(fromRing);
+  if (currentServer && uniqueServers.includes(currentServer)) {
+    set.add(currentServer);
+  }
+  return Array.from(set);
+};
+
+// 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/writeAck.ts
+var ACK_ENTRY_RETENTION_MS = 1e4;
+var ACK_ENTRY_MAX = 256;
+var replicationTargetKey = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var ackEntries = /* @__PURE__ */ new Map();
+var sweepAckEntries = () => {
+  const wallClock = Date.now();
+  for (const [key, entry] of ackEntries) {
+    if (entry.settledAt !== null && wallClock - entry.settledAt > ACK_ENTRY_RETENTION_MS) {
+      ackEntries.delete(key);
+    }
+  }
+  while (ackEntries.size > ACK_ENTRY_MAX) {
+    const oldest = ackEntries.keys().next().value;
+    if (oldest === void 0) break;
+    ackEntries.delete(oldest);
+  }
+};
+var isReplicationAckHandle = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const handle = value;
+  return typeof handle.primary?.then === "function" && handle.targets instanceof Map;
+};
+var asAckStatus = (ack) => ack.then(
+  (ok) => ok ? "acked" : "failed",
+  () => "failed"
+);
+var beginWriteAck = (dbKey) => {
+  let resolveOutcome = () => {
+  };
+  const promise = new Promise((resolve) => {
+    resolveOutcome = resolve;
+  });
+  const entry = {
+    promise,
+    settledAt: null,
+    servers: [],
+    primaryTargetKey: null,
+    planRegistered: false,
+    targetAcks: /* @__PURE__ */ new Map(),
+    settle: (status) => {
+      entry.settledAt = Date.now();
+      resolveOutcome(status);
+    }
+  };
+  ackEntries.set(dbKey, entry);
+  sweepAckEntries();
+  return {
+    settleWithReplication: (replication) => {
+      if (isReplicationAckHandle(replication)) {
+        entry.planRegistered = true;
+        entry.servers = [...replication.servers];
+        entry.primaryTargetKey = replicationTargetKey(replication.servers[0]);
+        for (const [key, ack] of replication.targets) {
+          entry.targetAcks.set(key, asAckStatus(ack));
+        }
+        void asAckStatus(replication.primary).then(
+          (status) => entry.settle(status)
+        );
+        return;
+      }
+      if (replication && typeof replication.then === "function") {
+        void asAckStatus(replication).then(
+          (status) => entry.settle(status)
+        );
+        return;
+      }
+      entry.settle("not-replicated");
+    },
+    markNotReplicated: () => entry.settle("not-replicated"),
+    markAborted: () => entry.settle("aborted")
+  };
+};
+
+// 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 null;
+  const [primaryServer, ...backupServers] = servers;
+  const targets = /* @__PURE__ */ new Map();
+  const settleTarget = /* @__PURE__ */ new Map();
+  for (const server of servers) {
+    const key = replicationTargetKey(server);
+    if (!key || targets.has(key)) continue;
+    targets.set(
+      key,
+      new Promise((resolve) => {
+        settleTarget.set(key, resolve);
+      })
+    );
+  }
+  const settleTargetFor = (server, ok) => {
+    const key = replicationTargetKey(server);
+    const resolve = settleTarget.get(key);
+    if (!resolve) return;
+    settleTarget.delete(key);
+    resolve(ok);
+  };
+  const primaryAck = Promise.resolve().then(async () => {
+    let primarySucceeded = false;
+    try {
+      primarySucceeded = await noloWriteRequest(primaryServer, request, state);
+    } finally {
+      settleTargetFor(primaryServer, primarySucceeded);
+    }
+    if (!primarySucceeded) {
+      console.warn(`Primary write sync failed for ${request.customKey} on ${primaryServer}`);
+    }
+    if (backupServers.length === 0) {
+      return primarySucceeded;
+    }
+    try {
+      syncWithServers(
+        backupServers,
+        (server, requestConfig, requestState, signal) => noloWriteRequest(server, requestConfig, requestState, signal, {
+          failureLogLevel: "info"
+        }).then(
+          (ok) => {
+            settleTargetFor(server, ok);
+            return ok;
+          },
+          (error) => {
+            settleTargetFor(server, false);
+            throw error;
+          }
+        ),
+        `Backup write sync failed for ${request.customKey} on`,
+        request,
+        state
+      );
+    } catch (error) {
+      for (const server of backupServers) settleTargetFor(server, false);
+      throw error;
+    }
+    return primarySucceeded;
+  });
+  return { servers: [...servers], primary: primaryAck, targets };
+};
+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,
+  signal,
+  onProgress
+}) => {
+  if (!currentServer) {
+    return false;
+  }
+  if (signal || onProgress) {
+    return noloUploadRequest(currentServer, uploadConfig, state, signal, onProgress);
+  }
+  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 {
+  selectRuntimeSnapshot,
+  selectRuntimeCurrentServer,
+  getRuntimeServerContext,
+  parseOwnerUserIdFromDbKey,
+  DEVICE_LOCAL_OWNER_ID,
+  isDeviceLocalOwnerId,
+  resolveEffectiveSpaceActorId,
+  isDeviceLocalSpaceMembership,
+  isDeviceLocalSpaceBody,
+  resolveRecordOwnerUserId,
+  resolveRecordAuthority,
+  beginWriteAck,
+  partitionReadServers,
+  compareRemoteRecordsByComparableTime,
+  pickBestSettledRemoteRecord,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord,
+  planAuthorityReadServers,
+  resolveReplicationServers,
+  resolveAuthorityReplicationServers,
+  scheduleWriteReplication,
+  resolveUploadReplicationServers,
+  scheduleExistingRecordReplication,
+  scheduleConfiguredPatchReplication,
+  scheduleUploadReplication,
+  uploadToCurrentServer,
+  scheduleDeleteReplication
+};