@lunora/solid 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/index.mjs

@@ -1,11 +1,19 @@
-export { LunoraContext, useLunora } from './packem_shared/LunoraContext-C9SpKj54.mjs';
-export { AuthLoading, Authenticated, Unauthenticated, createAuth } from './packem_shared/AuthLoading-RMT5Q_eE.mjs';
-export { default as createConnectionStatus } from './packem_shared/createConnectionStatus-D8GPatZX.mjs';
-export { createMutation, createMutationForClient } from './packem_shared/createMutation-C7BxzO0y.mjs';
-export { createInfiniteQuery, createPaginatedQuery } from './packem_shared/createInfiniteQuery-DyMvQ2Qy.mjs';
-export { createPresence } from './packem_shared/createPresence-DiAak1Jw.mjs';
-export { createQuery } from './packem_shared/createQuery-D8mdHfyQ.mjs';
+export { LunoraContext, useLunora } from './packem_shared/LunoraContext-C59PzHhN.mjs';
+export { createAgent } from './packem_shared/createAgent-D7EZBeql.mjs';
+export { createAgentChat } from './packem_shared/createAgentChat-Bq-wzSxv.mjs';
+export { createAgentState } from './packem_shared/createAgentState-DckYu3G8.mjs';
+export { createAgentToolEvents } from './packem_shared/createAgentToolEvents-UavTO16u.mjs';
+export { AuthLoading, Authenticated, Unauthenticated, createAuth } from './packem_shared/AuthLoading-u5QJoV-J.mjs';
+export { default as createConnectionStatus } from './packem_shared/createConnectionStatus-1poqwqR9.mjs';
+export { createFlag, createFlags } from './packem_shared/createFlag-DQoGdUMB.mjs';
+export { createMutation, createMutationForClient } from './packem_shared/createMutation-LkrbhItI.mjs';
+export { createMutator } from './packem_shared/createMutator-foSnPJPt.mjs';
+export { createInfiniteQuery, createPaginatedQuery } from './packem_shared/createInfiniteQuery-CD2GT1_O.mjs';
+export { createPresence } from './packem_shared/createPresence-DM2cVkiG.mjs';
+export { createQuery } from './packem_shared/createQuery-BUldvZXj.mjs';
 export { createRateLimit } from './packem_shared/createRateLimit-BA2f8XyF.mjs';
-export { createSubscription } from './packem_shared/createSubscription-BM2fw8hw.mjs';
-export { default as hydratePreloaded } from './packem_shared/hydratePreloaded-CaT1kDBH.mjs';
-export { LunoraProvider } from './packem_shared/LunoraProvider-B5BJFk3K.mjs';
+export { createStream } from './packem_shared/createStream-D9ONbGAw.mjs';
+export { createSubscription } from './packem_shared/createSubscription-D3HbChGe.mjs';
+export { createVoiceAgent } from './packem_shared/createVoiceAgent-hu59SaDl.mjs';
+export { default as hydratePreloaded } from './packem_shared/hydratePreloaded-CWny5-2J.mjs';
+export { LunoraProvider } from './packem_shared/LunoraProvider-CzB3zGhy.mjs';

package/dist/packem_shared/{AuthLoading-RMT5Q_eE.mjs → AuthLoading-u5QJoV-J.mjs}

@@ -1,7 +1,7 @@
 import { createComponent, memo } from 'solid-js/web';
 import { getIdentityStore } from '@lunora/client/auth';
 import { Show, createSignal, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const createAuth = () => {
   const client = useLunora();

package/dist/packem_shared/{LunoraContext-C9SpKj54.mjs → LunoraContext-C59PzHhN.mjs}

@@ -1,10 +1,11 @@
+import { LunoraError } from '@lunora/errors';
 import { createContext, useContext } from 'solid-js';
 
 const LunoraContext = createContext();
 const useLunora = () => {
   const client = useContext(LunoraContext);
   if (!client) {
-    throw new Error("useLunora must be used inside <LunoraProvider />");
+    throw new LunoraError("INTERNAL", "useLunora must be used inside <LunoraProvider />");
   }
   return client;
 };

package/dist/packem_shared/{LunoraProvider-B5BJFk3K.mjs → LunoraProvider-CzB3zGhy.mjs}

@@ -1,5 +1,5 @@
 import { createComponent } from 'solid-js/web';
-import { LunoraContext } from './LunoraContext-C9SpKj54.mjs';
+import { LunoraContext } from './LunoraContext-C59PzHhN.mjs';
 
 const LunoraProvider = (props) => (
   // `props.client` is read lazily inside the JSX so Solid tracks it: swapping

package/dist/packem_shared/createAgent-D7EZBeql.mjs

@@ -0,0 +1,55 @@
+import { createMemo } from 'solid-js';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_MUTATION_REF = {
+  __lunoraRef: ""
+};
+const resolveMaybe = (value) => typeof value === "function" ? value() : value;
+const createAgent = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    run: runReference,
+    runArgs,
+    threadKey
+  } = options;
+  const runMutation = createMutation(runReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const run = async (input, arguments_) => {
+    await runMutation.mutate({
+      input,
+      threadKey: resolveMaybe(threadKey),
+      ...runArgs,
+      ...arguments_
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    cancel,
+    pending: runMutation.pending,
+    run,
+    status,
+    thread
+  };
+};
+
+export { NO_MUTATION_REF, createAgent, resolveMaybe };

package/dist/packem_shared/createAgentChat-Bq-wzSxv.mjs

@@ -0,0 +1,166 @@
+import { createSignal, createMemo } from 'solid-js';
+import { resolveMaybe, NO_MUTATION_REF } from './createAgent-D7EZBeql.mjs';
+import { createMutation } from './createMutation-LkrbhItI.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const reconcileOptimistic = (optimistic, durable) => {
+  const durableUserRows = durable.filter((message) => message.role === "user");
+  const consumed = /* @__PURE__ */ new Set();
+  return optimistic.filter((pending) => {
+    for (let index = pending.durableUserCountAtSend; index < durableUserRows.length; index += 1) {
+      const row = durableUserRows[index];
+      if (row !== void 0 && !consumed.has(index) && row.content === pending.content) {
+        consumed.add(index);
+        return false;
+      }
+    }
+    return true;
+  });
+};
+const createAgentChat = (options) => {
+  const {
+    api,
+    cancel: cancelReference,
+    limit,
+    send: sendReference,
+    sendArgs,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  });
+  const {
+    data: threadData
+  } = createSubscription(api.agents.agentThread, () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  });
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const sendMutation = createMutation(sendReference);
+  const cancelMutation = createMutation(cancelReference ?? NO_MUTATION_REF);
+  const approvalMutation = createMutation(api.agents.agentResolveApproval);
+  const [optimistic, setOptimistic] = createSignal([]);
+  let nextId = 0;
+  const thread = createMemo(() => threadData());
+  const status = createMemo(() => thread()?.status);
+  const durable = createMemo(() => history() ?? []);
+  const messages = createMemo(() => {
+    const rows = durable();
+    const visible = reconcileOptimistic(optimistic(), rows);
+    if (visible.length === 0) {
+      return rows;
+    }
+    let maxDurableSeq = -1;
+    for (const message of rows) {
+      if (message.seq > maxDurableSeq) {
+        maxDurableSeq = message.seq;
+      }
+    }
+    return [...rows, ...visible.map((pending, index) => {
+      return {
+        content: pending.content,
+        optimistic: true,
+        role: "user",
+        seq: maxDurableSeq + 1 + index
+      };
+    })];
+  });
+  const streamingText = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const assistantCount = durable().filter((message) => message.role === "assistant").length;
+    return chunks().filter((event) => event.kind !== "progress" && event.threadKey === key && event.turn >= assistantCount).map((delta) => delta.text).join("");
+  });
+  const send = async (input, arguments_) => {
+    const id = nextId;
+    nextId += 1;
+    const durableUserCountAtSend = durable().filter((message) => message.role === "user").length;
+    setOptimistic((previous) => [...reconcileOptimistic(previous, durable()), {
+      content: input,
+      durableUserCountAtSend,
+      id
+    }]);
+    try {
+      await sendMutation.mutate({
+        input,
+        threadKey: resolveMaybe(threadKey),
+        ...sendArgs,
+        ...arguments_
+      });
+    } catch (error) {
+      setOptimistic((previous) => previous.filter((pending) => pending.id !== id));
+      throw error;
+    }
+  };
+  const approve = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot approve — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "approve",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const reject = async (toolCallId, note) => {
+    const instanceId = thread()?.instanceId;
+    if (instanceId === void 0) {
+      throw new Error("createAgentChat: cannot reject — no in-flight run (thread has no instanceId)");
+    }
+    await approvalMutation.mutate({
+      decision: "reject",
+      instanceId,
+      threadKey: resolveMaybe(threadKey),
+      toolCallId,
+      ...note === void 0 ? {} : {
+        note
+      }
+    });
+  };
+  const cancel = async () => {
+    const instanceId = thread()?.instanceId;
+    if (cancelReference === void 0 || instanceId === void 0) {
+      return;
+    }
+    await cancelMutation.mutate({
+      instanceId,
+      threadKey: resolveMaybe(threadKey)
+    });
+  };
+  return {
+    approve,
+    cancel,
+    messages,
+    reject,
+    send,
+    status,
+    streamingText
+  };
+};
+
+export { createAgentChat };

package/dist/packem_shared/createAgentState-DckYu3G8.mjs

@@ -0,0 +1,21 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const createAgentState = (options) => {
+  const {
+    data,
+    error
+  } = createSubscription(options.api.agents.agentState, () => {
+    return {
+      key: resolveMaybe(options.threadKey)
+    };
+  });
+  const state = createMemo(() => data());
+  return {
+    error,
+    state
+  };
+};
+
+export { createAgentState };

package/dist/packem_shared/createAgentToolEvents-UavTO16u.mjs

@@ -0,0 +1,99 @@
+import { createMemo } from 'solid-js';
+import { resolveMaybe } from './createAgent-D7EZBeql.mjs';
+import { createStream } from './createStream-D9ONbGAw.mjs';
+import { createSubscription } from './createSubscription-D3HbChGe.mjs';
+
+const NO_STREAM_REF = {
+  __lunoraRef: ""
+};
+const EMPTY_MESSAGES = [];
+const toDurableEvent = (message) => {
+  if (message.role === "assistant" && message.toolCalls) {
+    return message.toolCalls.map((call) => {
+      return {
+        input: call.input,
+        seq: message.seq,
+        toolCallId: call.id,
+        toolName: call.name,
+        type: "call"
+      };
+    });
+  }
+  if (message.role !== "tool") {
+    return void 0;
+  }
+  if (message.status === "awaiting_approval") {
+    return [{
+      seq: message.seq,
+      type: "awaiting-approval",
+      ...message.toolCallId === void 0 ? {} : {
+        toolCallId: message.toolCallId
+      },
+      ...message.toolName === void 0 ? {} : {
+        toolName: message.toolName
+      }
+    }];
+  }
+  return [{
+    output: message.content,
+    seq: message.seq,
+    type: "result",
+    ...message.status === "approved" || message.status === "rejected" ? {
+      status: message.status
+    } : {},
+    ...message.toolCallId === void 0 ? {} : {
+      toolCallId: message.toolCallId
+    },
+    ...message.toolName === void 0 ? {} : {
+      toolName: message.toolName
+    }
+  }];
+};
+const createAgentToolEvents = (options) => {
+  const {
+    api,
+    limit,
+    stream: streamReference,
+    threadKey
+  } = options;
+  const messagesArguments = () => {
+    const key = resolveMaybe(threadKey);
+    return limit === void 0 ? {
+      key
+    } : {
+      key,
+      limit
+    };
+  };
+  const {
+    data: history
+  } = createSubscription(api.agents.agentMessages, messagesArguments);
+  const streamArguments = streamReference === void 0 ? "skip" : () => {
+    return {
+      key: resolveMaybe(threadKey)
+    };
+  };
+  const {
+    chunks
+  } = createStream(streamReference ?? NO_STREAM_REF, streamArguments);
+  const events = createMemo(() => {
+    const key = resolveMaybe(threadKey);
+    const durable = history() ?? EMPTY_MESSAGES;
+    const derived = durable.flatMap((message) => toDurableEvent(message) ?? []);
+    for (const event of chunks()) {
+      if (event.kind === "progress" && event.threadKey === key) {
+        derived.push({
+          data: event.data,
+          toolCallId: event.toolCallId,
+          type: "progress"
+        });
+      }
+    }
+    return derived;
+  });
+  return {
+    events
+  };
+};
+
+export { createAgentToolEvents };

package/dist/packem_shared/{createConnectionStatus-D8GPatZX.mjs → createConnectionStatus-1poqwqR9.mjs}

@@ -1,5 +1,5 @@
 import { createSignal, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
 
 const createConnectionStatus = () => {
   const client = useLunora();

package/dist/packem_shared/createFlag-DQoGdUMB.mjs

@@ -0,0 +1,78 @@
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+
+const FLAGS_EVAL_PATH = "__lunora_flags__:eval";
+const flagKind = (value) => {
+  const kind = typeof value;
+  if (kind === "boolean" || kind === "number" || kind === "string") {
+    return kind;
+  }
+  return "object";
+};
+const flagsReference = {
+  __lunoraRef: FLAGS_EVAL_PATH
+};
+const resolveMaybe = (value) => typeof value === "function" ? value() : value;
+const serializeContext = (context) => context === void 0 ? "" : stableStringify(context);
+const createFlag = (key, defaultValue, context) => {
+  const client = useLunora();
+  const type = flagKind(defaultValue);
+  const [value, setValue] = createSignal(defaultValue);
+  createEffect(on(() => `${resolveMaybe(key)} ${serializeContext(resolveMaybe(context))}`, () => {
+    const currentKey = resolveMaybe(key);
+    const currentContext = resolveMaybe(context);
+    setValue(() => defaultValue);
+    let unsubscribe;
+    try {
+      unsubscribe = client.subscribe(flagsReference, {
+        context: currentContext,
+        default: defaultValue,
+        key: currentKey,
+        type
+      }, (next) => {
+        setValue(() => next);
+      });
+    } catch {
+      return;
+    }
+    onCleanup(unsubscribe);
+  }));
+  return value;
+};
+const createFlags = (flags, context) => {
+  const client = useLunora();
+  const [values, setValues] = createSignal(flags);
+  const spec = stableStringify(flags);
+  createEffect(on(() => `${spec} ${serializeContext(resolveMaybe(context))}`, () => {
+    const currentContext = resolveMaybe(context);
+    setValues(() => flags);
+    const unsubscribes = [];
+    for (const [key, defaultValue] of Object.entries(flags)) {
+      try {
+        unsubscribes.push(client.subscribe(flagsReference, {
+          context: currentContext,
+          default: defaultValue,
+          key,
+          type: flagKind(defaultValue)
+        }, (next) => {
+          setValues((previous) => {
+            return {
+              ...previous,
+              [key]: next
+            };
+          });
+        }));
+      } catch {
+      }
+    }
+    onCleanup(() => {
+      for (const unsubscribe of unsubscribes) {
+        unsubscribe();
+      }
+    });
+  }));
+  return values;
+};
+
+export { createFlag, createFlags };

package/dist/packem_shared/{createInfiniteQuery-DyMvQ2Qy.mjs → createInfiniteQuery-CD2GT1_O.mjs}

@@ -1,6 +1,105 @@
-import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
+import { initialPages, derivePaginationStatus, applyLoadMore, rebalance } from '@lunora/client/pagination';
 import { createMemo, createSignal, createEffect, on, onCleanup } from 'solid-js';
-import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+import { s as stableStringify } from './stable-key-DePnevIy.mjs';
+import { useLunora } from './LunoraContext-C59PzHhN.mjs';
+
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+
+const TAG = "$lunora.wire$";
+const MAX_DEPTH = 64;
+const encodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === void 0) {
+    return [TAG, "undefined"];
+  }
+  if (value === null) {
+    return null;
+  }
+  const kind = typeof value;
+  if (kind === "bigint") {
+    return [TAG, "bigint", value.toString()];
+  }
+  if (kind === "number") {
+    const numeric = value;
+    if (Number.isNaN(numeric)) {
+      return [TAG, "nan"];
+    }
+    if (numeric === Infinity) {
+      return [TAG, "inf"];
+    }
+    if (numeric === -Infinity) {
+      return [TAG, "-inf"];
+    }
+    return numeric;
+  }
+  if (kind !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
+  }
+  if (value instanceof Error) {
+    const error = value;
+    const properties = {};
+    for (const key of Object.keys(error)) {
+      if (error[key] !== void 0) {
+        properties[key] = encodeWire(error[key], depth + 1);
+      }
+    }
+    const encodedError = [TAG, "error", error.name, error.message, properties];
+    if (error.cause !== void 0) {
+      encodedError.push(encodeWire(error.cause, depth + 1));
+    }
+    return encodedError;
+  }
+  if (value instanceof URL) {
+    return [TAG, "url", value.href];
+  }
+  if (value instanceof Map) {
+    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
+  }
+  if (value instanceof Set) {
+    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
+  }
+  if (value instanceof ArrayBuffer) {
+    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    const ctorName = view.constructor.name;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
+  }
+  if (Array.isArray(value)) {
+    const encoded = value.map((item) => encodeWire(item, depth + 1));
+    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(`wire-codec: cannot encode a ${name} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`);
+  }
+  const source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const field = source[key];
+    if (field !== void 0) {
+      result[key] = encodeWire(field, depth + 1);
+    }
+  }
+  return result;
+};
+
+const stableWireKey = (value) => stableStringify(encodeWire(value));
 
 const buildPageArgs = (page, baseArgs) => {
   return {
@@ -12,7 +111,7 @@ const buildPageArgs = (page, baseArgs) => {
     }
   };
 };
-const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${stableWireKey(pageArgs)}`;
 const createPaginatedCore = (function_, args, options) => {
   const client = useLunora();
   const {
@@ -32,7 +131,23 @@ const createPaginatedCore = (function_, args, options) => {
     });
     setPageResults(updated);
   };
-  const syncSubscriptions = (currentPages, baseArgs) => {
+  const migrateResultsForRebalance = (oldPages, newPages, baseArgs) => {
+    const keyOf = (page) => buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs));
+    for (const newPage of newPages) {
+      const newKey = keyOf(newPage);
+      if (resultsByKey.has(newKey)) {
+        continue;
+      }
+      const donor = oldPages.find((oldPage) => oldPage.lower === newPage.lower);
+      if (donor) {
+        const carried = resultsByKey.get(keyOf(donor));
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+  };
+  const syncPass = (currentPages, baseArgs) => {
     const wantedKeys = /* @__PURE__ */ new Set();
     for (const page of currentPages) {
       wantedKeys.add(buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs)));
@@ -42,6 +157,7 @@ const createPaginatedCore = (function_, args, options) => {
         unsub();
         activeSubs.delete(key);
         pendingPageKeys.delete(key);
+        resultsByKey.delete(key);
       }
     }
     for (const page of currentPages) {
@@ -60,8 +176,10 @@ const createPaginatedCore = (function_, args, options) => {
         }
         rebuildPageResults(pages(), currentArgs);
         if (pendingPageKeys.size === 0) {
-          const next = rebalance(pages(), pageResults());
+          const latestPages = pages();
+          const next = rebalance(latestPages, pageResults());
           if (next) {
+            migrateResultsForRebalance(latestPages, next, currentArgs);
             setPages(next);
           }
         }
@@ -71,6 +189,31 @@ const createPaginatedCore = (function_, args, options) => {
       activeSubs.set(key, unsub);
     }
   };
+  let syncing = false;
+  let resyncRequested = false;
+  const syncSubscriptions = (currentPages, baseArgs) => {
+    if (syncing) {
+      resyncRequested = true;
+      return;
+    }
+    syncing = true;
+    try {
+      let pagesToSync = currentPages;
+      let argsToSync = baseArgs;
+      do {
+        resyncRequested = false;
+        syncPass(pagesToSync, argsToSync);
+        const latestArgs = resolveArgs();
+        if (latestArgs === "skip") {
+          break;
+        }
+        pagesToSync = pages();
+        argsToSync = latestArgs;
+      } while (resyncRequested);
+    } finally {
+      syncing = false;
+    }
+  };
   const teardownAll = () => {
     for (const unsub of activeSubs.values()) {
       unsub();