@rocicorp/zero 0.25.0-canary.1 → 0.25.0

package/out/{chunk-AIPM77UE.js → chunk-QZSBDHTA.js}

@@ -1512,6 +1512,103 @@ function rejectIfClosed(tx) {
   return tx.closed ? Promise.reject(new TransactionClosedError()) : void 0;
 }
 
+// ../shared/src/error.ts
+function getErrorMessage(error) {
+  return getErrorMessageInternal(error, /* @__PURE__ */ new Set());
+}
+function getErrorMessageInternal(error, seen) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    if (seen.has(error)) {
+      return "Circular error reference detected while extracting the error message.";
+    }
+    seen.add(error);
+  }
+  if (error instanceof Error) {
+    if (error.message) {
+      return error.message;
+    }
+    if ("cause" in error) {
+      const cause = error.cause;
+      if (cause !== void 0) {
+        const causeMessage = getErrorMessageInternal(cause, seen);
+        if (causeMessage) {
+          return causeMessage;
+        }
+      }
+    }
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    const message = error.message;
+    if (message) {
+      return message;
+    }
+  }
+  try {
+    const json2 = jsonSchema.parse(error);
+    return `Parsed message: ${JSON.stringify(json2)}`;
+  } catch (_e) {
+  }
+  return `Unknown error of type ${typeof error} was thrown and the message could not be determined. See cause for details.`;
+}
+function getErrorDetails(error) {
+  if (error instanceof Error) {
+    if ("details" in error) {
+      try {
+        return jsonSchema.parse(error?.details);
+      } catch (_e) {
+      }
+    }
+    if (error.name && error.name !== "Error") {
+      return { name: error.name };
+    }
+    return void 0;
+  }
+  if (typeof error === "object" && error !== null && "details" in error) {
+    try {
+      return jsonSchema.parse(error?.details);
+    } catch (_e) {
+    }
+  }
+  try {
+    return jsonSchema.parse(error);
+  } catch (_e) {
+  }
+  return void 0;
+}
+
+// ../zero-protocol/src/application-error.ts
+var ApplicationError = class extends Error {
+  /**
+   * This maps onto errors for transform and push app-level failures.
+   */
+  #details;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "ApplicationError";
+    this.#details = options?.details ?? void 0;
+  }
+  get details() {
+    return this.#details;
+  }
+};
+function isApplicationError(error) {
+  return error instanceof ApplicationError;
+}
+function wrapWithApplicationError(error) {
+  if (isApplicationError(error)) {
+    return error;
+  }
+  const message = getErrorMessage(error);
+  const details = getErrorDetails(error);
+  return new ApplicationError(message, {
+    cause: error,
+    details
+  });
+}
+
 // ../zero-protocol/src/error-kind-enum.ts
 var error_kind_enum_exports = {};
 __export(error_kind_enum_exports, {
@@ -1645,6 +1742,10 @@ var errorKindSchema = valita_exports.union(
 var pushFailedBaseSchema = valita_exports.object({
   kind: pushFailedErrorKindSchema,
   details: jsonSchema.optional(),
+  /**
+   * The mutationIDs of the mutations that failed to process.
+   * This can be a subset of the mutationIDs in the request.
+   */
   mutationIDs: valita_exports.array(mutationIDSchema),
   message: valita_exports.string()
 });
@@ -1677,6 +1778,9 @@ var pushFailedBodySchema = valita_exports.union(
 var transformFailedBaseSchema = valita_exports.object({
   kind: transformFailedErrorKindSchema,
   details: jsonSchema.optional(),
+  /**
+   * The queryIDs of the queries that failed to transform.
+   */
   queryIDs: valita_exports.array(valita_exports.string()),
   message: valita_exports.string()
 });
@@ -1742,38 +1846,24 @@ var transformedQuerySchema = valita_exports.object({
   name: valita_exports.string(),
   ast: astSchema
 });
-var appQueryErrorSchema = valita_exports.object({
+var appErroredQuerySchema = valita_exports.object({
   error: valita_exports.literal("app"),
   id: valita_exports.string(),
   name: valita_exports.string(),
-  details: jsonSchema
-});
-var zeroErrorSchema = valita_exports.object({
-  /** @deprecated */
-  error: valita_exports.literal("zero"),
-  /** @deprecated */
-  id: valita_exports.string(),
-  /** @deprecated */
-  name: valita_exports.string(),
-  /** @deprecated */
-  details: jsonSchema
+  // optional for backwards compatibility
+  message: valita_exports.string().optional(),
+  details: jsonSchema.optional()
 });
-var httpQueryErrorSchema = valita_exports.object({
-  /** @deprecated */
-  error: valita_exports.literal("http"),
-  /** @deprecated */
+var parseErroredQuerySchema = valita_exports.object({
+  error: valita_exports.literal("parse"),
   id: valita_exports.string(),
-  /** @deprecated */
   name: valita_exports.string(),
-  /** @deprecated */
-  status: valita_exports.number(),
-  /** @deprecated */
-  details: jsonSchema
+  message: valita_exports.string(),
+  details: jsonSchema.optional()
 });
 var erroredQuerySchema = valita_exports.union(
-  appQueryErrorSchema,
-  httpQueryErrorSchema,
-  zeroErrorSchema
+  appErroredQuerySchema,
+  parseErroredQuerySchema
 );
 var transformResponseBodySchema = valita_exports.array(
   valita_exports.union(transformedQuerySchema, erroredQuerySchema)
@@ -1814,7 +1904,7 @@ function string4() {
     customType: null
   });
 }
-function number4() {
+function number3() {
   return new ColumnBuilder({
     type: "number",
     optional: false,
@@ -2406,11 +2496,13 @@ __export(connection_status_enum_exports, {
   Connected: () => Connected,
   Connecting: () => Connecting,
   Disconnected: () => Disconnected,
-  Error: () => Error2
+  Error: () => Error2,
+  NeedsAuth: () => NeedsAuth
 });
 var Disconnected = "disconnected";
 var Connecting = "connecting";
 var Connected = "connected";
+var NeedsAuth = "needs-auth";
 var Error2 = "error";
 var Closed = "closed";
 
@@ -2431,7 +2523,7 @@ function isServerError(ex) {
 }
 function isAuthError(ex) {
   if (isServerError(ex)) {
-    if (isAuthErrorKind(ex.errorBody.kind)) {
+    if (ex.kind === error_kind_enum_exports.AuthInvalidated || ex.kind === error_kind_enum_exports.Unauthorized) {
       return true;
     }
     if ((ex.errorBody.kind === error_kind_enum_exports.PushFailed || ex.errorBody.kind === error_kind_enum_exports.TransformFailed) && ex.errorBody.reason === error_reason_enum_exports.HTTP && (ex.errorBody.status === 401 || ex.errorBody.status === 403)) {
@@ -2440,9 +2532,6 @@ function isAuthError(ex) {
   }
   return false;
 }
-function isAuthErrorKind(kind) {
-  return kind === error_kind_enum_exports.AuthInvalidated || kind === error_kind_enum_exports.Unauthorized;
-}
 function getBackoffParams(error) {
   if (isServerError(error)) {
     switch (error.errorBody.kind) {
@@ -2459,6 +2548,12 @@ function isClientError(ex) {
 }
 var NO_STATUS_TRANSITION = "NO_STATUS_TRANSITION";
 function getErrorConnectionTransition(ex) {
+  if (isAuthError(ex)) {
+    return {
+      status: connection_status_enum_exports.NeedsAuth,
+      reason: ex
+    };
+  }
   if (isClientError(ex)) {
     switch (ex.kind) {
       // Connecting errors that should continue in the current state
@@ -2486,9 +2581,6 @@ function getErrorConnectionTransition(ex) {
         unreachable(ex.kind);
     }
   }
-  if (isAuthError(ex)) {
-    return { status: NO_STATUS_TRANSITION, reason: ex };
-  }
   if (isServerError(ex)) {
     switch (ex.kind) {
       // Errors that should transition to error state
@@ -2502,6 +2594,8 @@ function getErrorConnectionTransition(ex) {
       case error_kind_enum_exports.VersionNotSupported:
       case error_kind_enum_exports.SchemaVersionNotSupported:
       case error_kind_enum_exports.Internal:
+      // PushFailed and TransformFailed can be auth errors (401/403)
+      // or other errors - handle non-auth cases here
       case error_kind_enum_exports.PushFailed:
       case error_kind_enum_exports.TransformFailed:
         return { status: connection_status_enum_exports.Error, reason: ex };
@@ -2510,11 +2604,13 @@ function getErrorConnectionTransition(ex) {
       case error_kind_enum_exports.Rehome:
       case error_kind_enum_exports.ServerOverloaded:
         return { status: NO_STATUS_TRANSITION, reason: ex };
-      // Auth errors will eventually transition to needs-auth state
-      // For now, treat them as non-fatal so we can retry
+      // Auth errors are handled above by isAuthError check
       case error_kind_enum_exports.AuthInvalidated:
       case error_kind_enum_exports.Unauthorized:
-        return { status: NO_STATUS_TRANSITION, reason: ex };
+        return {
+          status: connection_status_enum_exports.NeedsAuth,
+          reason: ex
+        };
       // Mutation-specific errors don't affect connection state
       case error_kind_enum_exports.MutationRateLimited:
       case error_kind_enum_exports.MutationFailed:
@@ -6821,9 +6917,10 @@ var pushMessageSchema = valita_exports.tuple([valita_exports.literal("push"), pu
 var appErrorSchema = valita_exports.object({
   error: valita_exports.literal("app"),
   // The user can return any additional data here
+  message: valita_exports.string().optional(),
   details: jsonSchema.optional()
 });
-var zeroErrorSchema2 = valita_exports.object({
+var zeroErrorSchema = valita_exports.object({
   error: valita_exports.union(
     /** @deprecated push oooMutation errors are now represented as ['error', { ... }] messages */
     valita_exports.literal("oooMutation"),
@@ -6835,7 +6932,7 @@ var mutationOkSchema = valita_exports.object({
   // The user can return any additional data here
   data: jsonSchema.optional()
 });
-var mutationErrorSchema = valita_exports.union(appErrorSchema, zeroErrorSchema2);
+var mutationErrorSchema = valita_exports.union(appErrorSchema, zeroErrorSchema);
 var mutationResultSchema = valita_exports.union(
   mutationOkSchema,
   mutationErrorSchema
@@ -7055,7 +7152,7 @@ var downstreamSchema = valita_exports.union(
 );
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 38;
+var PROTOCOL_VERSION = 39;
 var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 18;
 assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
 
@@ -9647,32 +9744,40 @@ var PlannerFanIn = class {
       }
     }
   }
-  estimateCost(branchPattern) {
+  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
     let totalCost = {
-      rows: 0,
-      runningCost: 0,
+      returnedRows: 0,
+      cost: 0,
+      scanEst: 0,
       startupCost: 0,
       selectivity: 0,
       limit: void 0
     };
-    branchPattern = branchPattern ?? [];
     if (this.#type === "FI") {
       const updatedPattern = [0, ...branchPattern];
       let maxrows = 0;
       let maxRunningCost = 0;
       let maxStartupCost = 0;
+      let maxScanEst = 0;
       let noMatchProb = 1;
       for (const input of this.#inputs) {
-        const cost = input.estimateCost(updatedPattern);
-        if (cost.rows > maxrows) {
-          maxrows = cost.rows;
+        const cost = input.estimateCost(
+          downstreamChildSelectivity,
+          updatedPattern,
+          planDebugger
+        );
+        if (cost.returnedRows > maxrows) {
+          maxrows = cost.returnedRows;
         }
-        if (cost.runningCost > maxRunningCost) {
-          maxRunningCost = cost.runningCost;
+        if (cost.cost > maxRunningCost) {
+          maxRunningCost = cost.cost;
         }
         if (cost.startupCost > maxStartupCost) {
           maxStartupCost = cost.startupCost;
         }
+        if (cost.scanEst > maxScanEst) {
+          maxScanEst = cost.scanEst;
+        }
         noMatchProb *= 1 - cost.selectivity;
         assert(
           totalCost.limit === void 0 || cost.limit === totalCost.limit,
@@ -9680,19 +9785,25 @@ var PlannerFanIn = class {
         );
         totalCost.limit = cost.limit;
       }
-      totalCost.rows = maxrows;
-      totalCost.runningCost = maxRunningCost;
-      totalCost.startupCost = maxStartupCost;
+      totalCost.returnedRows = maxrows;
+      totalCost.cost = maxRunningCost;
       totalCost.selectivity = 1 - noMatchProb;
+      totalCost.startupCost = maxStartupCost;
+      totalCost.scanEst = maxScanEst;
     } else {
       let i = 0;
       let noMatchProb = 1;
       for (const input of this.#inputs) {
         const updatedPattern = [i, ...branchPattern];
-        const cost = input.estimateCost(updatedPattern);
-        totalCost.rows += cost.rows;
-        totalCost.runningCost += cost.runningCost;
-        totalCost.startupCost += cost.startupCost;
+        const cost = input.estimateCost(
+          downstreamChildSelectivity,
+          updatedPattern,
+          planDebugger
+        );
+        totalCost.returnedRows += cost.returnedRows;
+        totalCost.cost += cost.cost;
+        totalCost.scanEst += cost.scanEst;
+        totalCost.startupCost = totalCost.startupCost + cost.startupCost;
         noMatchProb *= 1 - cost.selectivity;
         assert(
           totalCost.limit === void 0 || cost.limit === totalCost.limit,
@@ -9703,19 +9814,45 @@ var PlannerFanIn = class {
       }
       totalCost.selectivity = 1 - noMatchProb;
     }
+    planDebugger?.log({
+      type: "node-cost",
+      nodeType: "fan-in",
+      node: this.#type,
+      branchPattern,
+      downstreamChildSelectivity,
+      costEstimate: totalCost
+    });
     return totalCost;
   }
-  propagateConstraints(branchPattern, constraint, from) {
+  propagateConstraints(branchPattern, constraint, from, planDebugger) {
+    planDebugger?.log({
+      type: "node-constraint",
+      nodeType: "fan-in",
+      node: this.#type,
+      branchPattern,
+      constraint,
+      from: from?.kind ?? "unknown"
+    });
     if (this.#type === "FI") {
       const updatedPattern = [0, ...branchPattern];
       for (const input of this.#inputs) {
-        input.propagateConstraints(updatedPattern, constraint, from);
+        input.propagateConstraints(
+          updatedPattern,
+          constraint,
+          this,
+          planDebugger
+        );
       }
       return;
     }
     let i = 0;
     for (const input of this.#inputs) {
-      input.propagateConstraints([i, ...branchPattern], constraint, from);
+      input.propagateConstraints(
+        [i, ...branchPattern],
+        constraint,
+        this,
+        planDebugger
+      );
       i++;
     }
   }
@@ -9743,11 +9880,37 @@ var PlannerFanOut = class {
   closestJoinOrSource() {
     return this.#input.closestJoinOrSource();
   }
-  propagateConstraints(branchPattern, constraint, _from) {
-    this.#input.propagateConstraints(branchPattern, constraint, this);
+  propagateConstraints(branchPattern, constraint, from, planDebugger) {
+    planDebugger?.log({
+      type: "node-constraint",
+      nodeType: "fan-out",
+      node: "FO",
+      branchPattern,
+      constraint,
+      from: from?.kind ?? "unknown"
+    });
+    this.#input.propagateConstraints(
+      branchPattern,
+      constraint,
+      this,
+      planDebugger
+    );
   }
-  estimateCost(branchPattern) {
-    return this.#input.estimateCost(branchPattern);
+  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
+    const ret = this.#input.estimateCost(
+      downstreamChildSelectivity,
+      branchPattern,
+      planDebugger
+    );
+    planDebugger?.log({
+      type: "node-cost",
+      nodeType: "fan-out",
+      node: "FO",
+      branchPattern,
+      downstreamChildSelectivity,
+      costEstimate: ret
+    });
+    return ret;
   }
   convertToUFO() {
     this.#type = "UFO";
@@ -9810,19 +9973,14 @@ var PlannerConnection = class {
    * a single join in the UFO is flipped - other branches report undefined.
    */
   #constraints;
-  /**
-   * Cached total cost (sum of all branches) to avoid redundant calculations.
-   * Invalidated when constraints change.
-   */
-  #cachedTotalCost = void 0;
+  #isRoot;
   /**
    * Cached per-constraint costs to avoid redundant cost model calls.
    * Maps constraint key (branch pattern string) to computed cost.
    * Invalidated when constraints change.
    */
   #cachedConstraintCosts = /* @__PURE__ */ new Map();
-  #costDirty = true;
-  constructor(table2, model, sort, filters, baseConstraints, limit, name) {
+  constructor(table2, model, sort, filters, isRoot, baseConstraints, limit, name) {
     this.table = table2;
     this.name = name ?? table2;
     this.#sort = sort;
@@ -9832,6 +9990,7 @@ var PlannerConnection = class {
     this.#baseLimit = limit;
     this.limit = limit;
     this.#constraints = /* @__PURE__ */ new Map();
+    this.#isRoot = isRoot;
     if (limit !== void 0 && filters) {
       const costWithFilters = model(table2, sort, filters, void 0);
       const costWithoutFilters = model(table2, sort, void 0, void 0);
@@ -9864,79 +10023,20 @@ var PlannerConnection = class {
    * The max of the last element of the paths is the number of
    * root branches.
    */
-  propagateConstraints(path, c) {
+  propagateConstraints(path, c, from, planDebugger) {
     const key = path.join(",");
     this.#constraints.set(key, c);
-    this.#cachedTotalCost = void 0;
     this.#cachedConstraintCosts.clear();
-    this.#costDirty = true;
+    planDebugger?.log({
+      type: "node-constraint",
+      nodeType: "connection",
+      node: this.name,
+      branchPattern: path,
+      constraint: c,
+      from: from?.kind ?? "unknown"
+    });
   }
-  estimateCost(branchPattern) {
-    if (branchPattern === void 0) {
-      if (!this.#costDirty && this.#cachedTotalCost !== void 0) {
-        return this.#cachedTotalCost;
-      }
-      let totalRows = 0;
-      let maxStartupCost = 0;
-      if (this.#constraints.size === 0) {
-        const key2 = "";
-        let cost2 = this.#cachedConstraintCosts.get(key2);
-        if (cost2 === void 0) {
-          const { startupCost: startupCost2, rows: rows2 } = this.#model(
-            this.table,
-            this.#sort,
-            this.#filters,
-            this.#baseConstraints
-          );
-          cost2 = {
-            rows: rows2,
-            runningCost: rows2,
-            startupCost: startupCost2,
-            selectivity: this.selectivity,
-            limit: this.limit
-          };
-          this.#cachedConstraintCosts.set(key2, cost2);
-        }
-        totalRows = cost2.rows;
-        maxStartupCost = cost2.startupCost;
-      } else {
-        for (const [key2, constraint2] of this.#constraints.entries()) {
-          let cost2 = this.#cachedConstraintCosts.get(key2);
-          if (cost2 === void 0) {
-            const mergedConstraint2 = mergeConstraints(
-              this.#baseConstraints,
-              constraint2
-            );
-            const { startupCost: startupCost2, rows: rows2 } = this.#model(
-              this.table,
-              this.#sort,
-              this.#filters,
-              mergedConstraint2
-            );
-            cost2 = {
-              rows: rows2,
-              runningCost: rows2,
-              startupCost: startupCost2,
-              selectivity: this.selectivity,
-              limit: this.limit
-            };
-            this.#cachedConstraintCosts.set(key2, cost2);
-          }
-          totalRows += cost2.rows;
-          maxStartupCost = Math.max(maxStartupCost, cost2.startupCost);
-        }
-      }
-      const ret = {
-        rows: totalRows,
-        runningCost: totalRows,
-        startupCost: maxStartupCost,
-        selectivity: this.selectivity,
-        limit: this.limit
-      };
-      this.#cachedTotalCost = ret;
-      this.#costDirty = false;
-      return ret;
-    }
+  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
     const key = branchPattern.join(",");
     let cost = this.#cachedConstraintCosts.get(key);
     if (cost !== void 0) {
@@ -9954,13 +10054,23 @@ var PlannerConnection = class {
       mergedConstraint
     );
     cost = {
-      rows,
-      runningCost: rows,
       startupCost,
+      scanEst: this.limit === void 0 ? rows : Math.min(rows, this.limit / downstreamChildSelectivity),
+      cost: 0,
+      returnedRows: rows,
       selectivity: this.selectivity,
       limit: this.limit
     };
     this.#cachedConstraintCosts.set(key, cost);
+    planDebugger?.log({
+      type: "node-cost",
+      nodeType: "connection",
+      node: this.name,
+      branchPattern,
+      downstreamChildSelectivity,
+      costEstimate: cost,
+      filters: this.#filters
+    });
     return cost;
   }
   /**
@@ -9969,6 +10079,9 @@ var PlannerConnection = class {
    * outer loop that should produce all rows rather than stopping at the limit.
    */
   unlimit() {
+    if (this.#isRoot) {
+      return;
+    }
     if (this.limit !== void 0) {
       this.limit = void 0;
     }
@@ -9983,9 +10096,7 @@ var PlannerConnection = class {
   reset() {
     this.#constraints.clear();
     this.limit = this.#baseLimit;
-    this.#cachedTotalCost = void 0;
     this.#cachedConstraintCosts.clear();
-    this.#costDirty = true;
   }
   /**
    * Capture constraint state for snapshotting.
@@ -10003,9 +10114,7 @@ var PlannerConnection = class {
     for (const [key, value] of constraints) {
       this.#constraints.set(key, value);
     }
-    this.#cachedTotalCost = void 0;
     this.#cachedConstraintCosts.clear();
-    this.#costDirty = true;
   }
   /**
    * Get current constraints for debugging.
@@ -10014,13 +10123,19 @@ var PlannerConnection = class {
   getConstraintsForDebug() {
     return new Map(this.#constraints);
   }
+  /**
+   * Get filters for debugging.
+   * Returns the filters applied to this connection.
+   */
+  getFiltersForDebug() {
+    return this.#filters;
+  }
   /**
    * Get estimated cost for each constraint branch.
    * Returns a map of constraint key to cost estimate.
    * Forces cost calculation if not already cached.
    */
   getConstraintCostsForDebug() {
-    this.estimateCost(void 0);
     return new Map(this.#cachedConstraintCosts);
   }
 };
@@ -10033,12 +10148,13 @@ var PlannerSource = class {
     this.name = name;
     this.#model = model;
   }
-  connect(sort, filters, baseConstraints, limit) {
+  connect(sort, filters, isRoot, baseConstraints, limit) {
     return new PlannerConnection(
       this.name,
       this.#model,
       sort,
       filters,
+      isRoot,
       baseConstraints,
       limit
     );
@@ -10107,20 +10223,20 @@ var PlannerGraph = class {
    * This sends constraints up through the graph to update
    * connection cost estimates.
    */
-  propagateConstraints() {
+  propagateConstraints(planDebugger) {
     assert(
       this.#terminus !== void 0,
       "Cannot propagate constraints without a terminus node"
     );
-    this.#terminus.propagateConstraints();
+    this.#terminus.propagateConstraints(planDebugger);
   }
   /**
    * Calculate total cost of the current plan.
    * Total cost includes both startup cost (one-time, e.g., sorting) and running cost.
    */
-  getTotalCost() {
-    const estimate = must(this.#terminus).estimateCost();
-    return estimate.startupCost + estimate.runningCost;
+  getTotalCost(planDebugger) {
+    const estimate = must(this.#terminus).estimateCost(planDebugger);
+    return estimate.cost + estimate.startupCost;
   }
   /**
    * Capture a lightweight snapshot of the current planning state.
@@ -10157,41 +10273,6 @@ var PlannerGraph = class {
     this.#restoreJoins(state);
     this.#restoreFanNodes(state);
   }
-  /**
-   * Collect cost estimates from all nodes in the graph for debugging.
-   */
-  #collectNodeCosts() {
-    const costs = [];
-    for (const c of this.connections) {
-      costs.push({
-        node: c.name,
-        nodeType: "connection",
-        costEstimate: c.estimateCost(void 0)
-      });
-    }
-    for (const j of this.joins) {
-      costs.push({
-        node: j.getName(),
-        nodeType: "join",
-        costEstimate: j.estimateCost(void 0)
-      });
-    }
-    for (const fo of this.fanOuts) {
-      costs.push({
-        node: "FO",
-        nodeType: "fan-out",
-        costEstimate: fo.estimateCost(void 0)
-      });
-    }
-    for (const fi of this.fanIns) {
-      costs.push({
-        node: "FI",
-        nodeType: "fan-in",
-        costEstimate: fi.estimateCost(void 0)
-      });
-    }
-    return costs;
-  }
   /**
    * Validate that snapshot shape matches current graph structure.
    */
@@ -10282,7 +10363,11 @@ var PlannerGraph = class {
     let bestCost = Infinity;
     let bestPlan = void 0;
     let bestAttemptNumber = -1;
+    const forcePattern = void 0;
     for (let pattern = 0; pattern < numPatterns; pattern++) {
+      if (forcePattern !== void 0 && pattern !== forcePattern) {
+        continue;
+      }
       this.resetPlanningState();
       if (planDebugger) {
         planDebugger.log({
@@ -10299,7 +10384,7 @@ var PlannerGraph = class {
         }
         checkAndConvertFOFI(fofiCache);
         propagateUnlimitForFlippedJoins(this);
-        this.propagateConstraints();
+        this.propagateConstraints(planDebugger);
         if (planDebugger) {
           planDebugger.log({
             type: "constraints-propagated",
@@ -10311,13 +10396,16 @@ var PlannerGraph = class {
             }))
           });
         }
-        const totalCost = this.getTotalCost();
+        const totalCost = this.getTotalCost(planDebugger);
         if (planDebugger) {
           planDebugger.log({
             type: "plan-complete",
             attemptNumber: pattern,
             totalCost,
-            nodeCosts: this.#collectNodeCosts(),
+            flipPattern: pattern,
+            // Bitmask of which joins are flipped
+            // TODO: we'll need a different way to collect these
+            // nodeCosts: this.#collectNodeCosts(),
             joinStates: this.joins.map((j) => {
               const info = j.getDebugInfo();
               return {
@@ -10345,12 +10433,14 @@ var PlannerGraph = class {
     }
     if (bestPlan) {
       this.restorePlanningSnapshot(bestPlan);
-      this.propagateConstraints();
+      this.propagateConstraints(planDebugger);
       if (planDebugger) {
         planDebugger.log({
           type: "best-plan-selected",
           bestAttemptNumber,
           totalCost: bestCost,
+          flipPattern: bestAttemptNumber,
+          // The best attempt number is also the flip pattern
           joinStates: this.joins.map((j) => ({
             join: j.getName(),
             type: j.type
@@ -10418,7 +10508,19 @@ function propagateUnlimitForFlippedJoins(graph) {
 }
 
 // ../zql/src/planner/planner-join.ts
-var SEMI_JOIN_OVERHEAD_MULTIPLIER = 1.5;
+function translateConstraintsForFlippedJoin(incomingConstraint, parentConstraint, childConstraint) {
+  if (!incomingConstraint) return void 0;
+  const parentKeys = Object.keys(parentConstraint);
+  const childKeys = Object.keys(childConstraint);
+  const translated = {};
+  for (const [key, value] of Object.entries(incomingConstraint)) {
+    const index = parentKeys.indexOf(key);
+    if (index !== -1) {
+      translated[childKeys[index]] = value;
+    }
+  }
+  return Object.keys(translated).length > 0 ? translated : void 0;
+}
 var PlannerJoin = class {
   kind = "join";
   #parent;
@@ -10476,9 +10578,13 @@ var PlannerJoin = class {
     return this.#flippable;
   }
   /**
-   * Propagate unlimiting through the child subgraph when this join is flipped.
-   * When a join is flipped, the child becomes the outer loop and should produce
-   * all rows rather than stopping at an EXISTS limit.
+   * Propagate unlimiting when this join is flipped.
+   * When a join is flipped:
+   * 1. Child becomes outer loop → produces all rows (unlimited)
+   * 2. Parent is fetched once per child row → effectively unlimited
+   *
+   * Example: If child produces 896 rows, parent is fetched 896 times.
+   * Even if each fetch returns 1 row, parent produces 896 total rows.
    *
    * Propagation rules:
    * - Connection: call unlimit()
@@ -10488,7 +10594,8 @@ var PlannerJoin = class {
    */
   propagateUnlimit() {
     assert(this.#type === "flipped", "Can only unlimit a flipped join");
-    propagateUnlimitToNode(this.#child);
+    this.#parent.propagateUnlimitFromFlippedJoin();
+    this.#child.propagateUnlimitFromFlippedJoin();
   }
   /**
    * Called when a parent join is flipped and this join is part of its child subgraph.
@@ -10497,56 +10604,99 @@ var PlannerJoin = class {
    */
   propagateUnlimitFromFlippedJoin() {
     if (this.#type === "semi") {
-      propagateUnlimitToNode(this.#parent);
+      this.#parent.propagateUnlimitFromFlippedJoin();
     }
   }
-  propagateConstraints(branchPattern, constraint) {
+  propagateConstraints(branchPattern, constraint, from, planDebugger) {
+    planDebugger?.log({
+      type: "node-constraint",
+      nodeType: "join",
+      node: this.getName(),
+      branchPattern,
+      constraint,
+      from: from ? getNodeName(from) : "unknown"
+    });
     if (this.#type === "semi") {
       this.#child.propagateConstraints(
         branchPattern,
         this.#childConstraint,
-        this
+        this,
+        planDebugger
+      );
+      this.#parent.propagateConstraints(
+        branchPattern,
+        constraint,
+        this,
+        planDebugger
       );
-      this.#parent.propagateConstraints(branchPattern, constraint, this);
     } else if (this.#type === "flipped") {
-      this.#child.propagateConstraints(branchPattern, void 0, this);
+      const translatedConstraint = translateConstraintsForFlippedJoin(
+        constraint,
+        this.#parentConstraint,
+        this.#childConstraint
+      );
+      this.#child.propagateConstraints(
+        branchPattern,
+        translatedConstraint,
+        this,
+        planDebugger
+      );
       this.#parent.propagateConstraints(
         branchPattern,
         mergeConstraints(constraint, this.#parentConstraint),
-        this
+        this,
+        planDebugger
       );
     }
   }
   reset() {
     this.#type = "semi";
   }
-  estimateCost(branchPattern) {
-    const parentCost = this.#parent.estimateCost(branchPattern);
-    const childCost = this.#child.estimateCost(branchPattern);
-    let scanEst = parentCost.rows;
-    if (this.#type === "semi" && parentCost.limit !== void 0) {
-      if (childCost.selectivity !== 0) {
-        scanEst = Math.min(scanEst, parentCost.limit / childCost.selectivity);
-      }
-    }
-    if (this.#parent.closestJoinOrSource() === "join") {
-      const pipelineCost = this.#type === "flipped" ? childCost.startupCost + childCost.runningCost * (parentCost.startupCost + parentCost.runningCost) : parentCost.runningCost + SEMI_JOIN_OVERHEAD_MULTIPLIER * scanEst * (childCost.startupCost + childCost.runningCost);
-      return {
-        rows: parentCost.rows,
-        runningCost: pipelineCost,
-        startupCost: parentCost.startupCost,
-        selectivity: parentCost.selectivity,
-        limit: parentCost.limit
+  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
+    const child = this.#child.estimateCost(1, branchPattern, planDebugger);
+    const parent = this.#parent.estimateCost(
+      // Selectivity flows up the graph from child to parent
+      // so we can determine the total selectivity of all ANDed exists checks.
+      child.selectivity * downstreamChildSelectivity,
+      branchPattern,
+      planDebugger
+    );
+    let costEstimate;
+    if (this.type === "semi") {
+      costEstimate = {
+        startupCost: parent.startupCost,
+        scanEst: parent.limit === void 0 ? parent.returnedRows : Math.min(
+          parent.returnedRows,
+          parent.limit / downstreamChildSelectivity
+        ),
+        cost: parent.cost + parent.scanEst * (child.startupCost + child.scanEst),
+        returnedRows: parent.returnedRows * child.selectivity,
+        selectivity: child.selectivity * parent.selectivity,
+        limit: parent.limit
+      };
+    } else {
+      costEstimate = {
+        startupCost: child.startupCost,
+        scanEst: parent.limit === void 0 ? parent.returnedRows : Math.min(
+          parent.returnedRows * child.returnedRows,
+          parent.limit / downstreamChildSelectivity
+        ),
+        cost: child.cost + child.scanEst * (parent.startupCost + parent.scanEst),
+        returnedRows: parent.returnedRows * child.returnedRows * child.selectivity,
+        selectivity: parent.selectivity * child.selectivity,
+        limit: parent.limit
       };
     }
-    const nestedLoopCost = this.#type === "flipped" ? childCost.runningCost * (parentCost.startupCost + parentCost.runningCost) : SEMI_JOIN_OVERHEAD_MULTIPLIER * scanEst * (childCost.startupCost + childCost.runningCost);
-    return {
-      rows: parentCost.rows,
-      runningCost: nestedLoopCost,
-      startupCost: parentCost.startupCost,
-      selectivity: parentCost.selectivity,
-      limit: parentCost.limit
-    };
+    planDebugger?.log({
+      type: "node-cost",
+      nodeType: "join",
+      node: this.getName(),
+      branchPattern,
+      downstreamChildSelectivity,
+      costEstimate,
+      joinType: this.#type
+    });
+    return costEstimate;
   }
   /**
    * Get a human-readable name for this join for debugging.
@@ -10588,11 +10738,6 @@ function getNodeName(node) {
       return "terminus";
   }
 }
-function propagateUnlimitToNode(node) {
-  if ("propagateUnlimitFromFlippedJoin" in node && typeof node.propagateUnlimitFromFlippedJoin === "function") {
-    node.propagateUnlimitFromFlippedJoin();
-  }
-}
 
 // ../zql/src/planner/planner-terminus.ts
 var PlannerTerminus = class {
@@ -10607,11 +10752,11 @@ var PlannerTerminus = class {
   closestJoinOrSource() {
     return this.#input.closestJoinOrSource();
   }
-  propagateConstraints() {
-    this.#input.propagateConstraints([], void 0, this);
+  propagateConstraints(planDebugger) {
+    this.#input.propagateConstraints([], void 0, this, planDebugger);
   }
-  estimateCost() {
-    return this.#input.estimateCost([]);
+  estimateCost(planDebugger) {
+    return this.#input.estimateCost(1, [], planDebugger);
   }
   /**
    * Propagate unlimiting when a parent join is flipped.
@@ -10636,13 +10781,14 @@ function wireOutput(from, to) {
       assert(false, "Terminus nodes cannot have outputs");
   }
 }
-function buildPlanGraph(ast, model, baseConstraints) {
+function buildPlanGraph(ast, model, isRoot, baseConstraints) {
   const graph = new PlannerGraph();
   let nextPlanId = 0;
   const source = graph.addSource(ast.table, model);
   const connection = source.connect(
     ast.orderBy ?? [],
     ast.where,
+    isRoot,
     baseConstraints,
     ast.limit
   );
@@ -10672,7 +10818,12 @@ function buildPlanGraph(ast, model, baseConstraints) {
         csq.correlation.childField,
         csq.subquery.table
       );
-      subPlans[alias] = buildPlanGraph(csq.subquery, model, childConstraints);
+      subPlans[alias] = buildPlanGraph(
+        csq.subquery,
+        model,
+        true,
+        childConstraints
+      );
     }
   }
   return { plan: graph, subPlans };
@@ -10747,6 +10898,7 @@ function processCorrelatedSubquery(condition, input, graph, model, parentTable,
   const childConnection = childSource.connect(
     related.subquery.orderBy ?? [],
     related.subquery.where,
+    false,
     void 0,
     // no base constraints for EXISTS/NOT EXISTS
     condition.op === "EXISTS" ? 1 : void 0
@@ -10805,7 +10957,7 @@ function planRecursively(plans, planDebugger) {
   plans.plan.plan(planDebugger);
 }
 function planQuery(ast, model, planDebugger) {
-  const plans = buildPlanGraph(ast, model);
+  const plans = buildPlanGraph(ast, model, true);
   planRecursively(plans, planDebugger);
   return applyPlansToAST(ast, plans);
 }
@@ -12690,6 +12842,7 @@ var Subscribable = class {
 // ../zero-client/src/client/connection-manager.ts
 var DEFAULT_TIMEOUT_CHECK_INTERVAL_MS = 1e3;
 var TERMINAL_STATES = [
+  connection_status_enum_exports.NeedsAuth,
   connection_status_enum_exports.Error
 ];
 var ConnectionManager = class _ConnectionManager extends Subscribable {
@@ -12758,8 +12911,8 @@ var ConnectionManager = class _ConnectionManager extends Subscribable {
   }
   /**
    * Returns true if the run loop should continue.
-   * The run loop continues in disconnected, connecting, connected, and error states.
-   * It stops in closed state.
+   * The run loop continues in all states except closed.
+   * In needs-auth and error states, the run loop pauses and waits for connect() to be called.
    */
   shouldContinueRunLoop() {
     return this.#state.name !== connection_status_enum_exports.Closed;
@@ -12858,10 +13011,33 @@ var ConnectionManager = class _ConnectionManager extends Subscribable {
     const nextStatePromise = this.#publishStateAndGetPromise();
     return { nextStatePromise };
   }
+  /**
+   * Transition to needs-auth state.
+   * This pauses the run loop until connect() is called with new credentials.
+   * Resets the retry window and attempt counter.
+   *
+   * @returns An object containing a promise that resolves on the next state change.
+   */
+  needsAuth(reason) {
+    if (this.#state.name === connection_status_enum_exports.Closed) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    if (this.#state.name === connection_status_enum_exports.NeedsAuth) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    this.#connectingStartedAt = void 0;
+    this.#maybeStopTimeoutInterval();
+    this.#state = {
+      name: connection_status_enum_exports.NeedsAuth,
+      reason
+    };
+    const nextStatePromise = this.#publishStateAndGetPromise();
+    return { nextStatePromise };
+  }
   /**
    * Transition to error state.
    * This pauses the run loop until connect() is called.
-   * Resets the 5-minute retry window and attempt counter.
+   * Resets the retry window and attempt counter.
    *
    * @returns An object containing a promise that resolves on the next state change.
    */
@@ -12971,16 +13147,22 @@ var ConnectionImpl = class {
   #connectionManager;
   #lc;
   #source;
-  constructor(connectionManager, lc) {
+  #setAuth;
+  constructor(connectionManager, lc, setAuth) {
     this.#connectionManager = connectionManager;
     this.#lc = lc;
     this.#source = new ConnectionSource(connectionManager);
+    this.#setAuth = setAuth;
   }
   get state() {
     return this.#source;
   }
-  async connect() {
+  async connect(opts) {
     const lc = this.#lc.withContext("connect");
+    if (opts && "auth" in opts) {
+      lc.debug?.("Updating auth credential from connect()");
+      this.#setAuth(opts.auth);
+    }
     if (!this.#connectionManager.isInTerminalState()) {
       lc.debug?.(
         "connect() called but not in a terminal state. Current state:",
@@ -14948,7 +15130,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.25.0-canary.1";
+var version2 = "0.25.0";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15328,7 +15510,7 @@ var MutationTracker = class {
   rejectMutation(id, e) {
     const entry = this.#outstandingMutations.get(id);
     if (entry) {
-      this.#settleMutation(id, entry, "reject", e);
+      this.#settleMutation(id, entry, "reject", wrapWithApplicationError(e));
     }
   }
   /**
@@ -15514,7 +15696,17 @@ var MutationTracker = class {
     );
     const entry = this.#outstandingMutations.get(ephemeralID);
     assert(entry && entry.mutationID === mid);
-    this.#settleMutation(ephemeralID, entry, "reject", error);
+    this.#settleMutation(
+      ephemeralID,
+      entry,
+      "reject",
+      error.error === "app" ? new ApplicationError(
+        error.message ?? `Unknown application error: ${error.error}`,
+        error.details ? { details: error.details } : void 0
+      ) : new Error(
+        error.error === "alreadyProcessed" ? "Mutation already processed" : error.error === "oooMutation" ? "Server reported an out-of-order mutation" : `Unknown fallback error with mutation ID ${mid}: ${error.error}`
+      )
+    );
     if (error.error === "oooMutation") {
       this.#onFatalError(
         new ProtocolError({
@@ -15709,27 +15901,20 @@ var QueryManager = class {
     for (const error of errors) {
       const queryId = error.id;
       const entry = this.#queries.get(queryId);
-      if (entry) {
-        entry.gotCallbacks.forEach((callback) => callback(false, error));
+      if (!entry) {
+        continue;
       }
-      if (error.error !== "app") {
+      if (error.error === "app" || error.error === "parse") {
+        entry.gotCallbacks.forEach((callback) => callback(false, error));
+      } else {
         this.#onFatalError(
-          new ProtocolError(
-            error.error === "http" ? {
-              kind: error_kind_enum_exports.TransformFailed,
-              origin: error_origin_enum_exports.ZeroCache,
-              reason: error_reason_enum_exports.HTTP,
-              message: `HTTP ${error.status} transforming queries`,
-              status: error.status,
-              queryIDs: []
-            } : {
-              kind: error_kind_enum_exports.TransformFailed,
-              origin: error_origin_enum_exports.ZeroCache,
-              reason: error_reason_enum_exports.Internal,
-              message: `Unknown error transforming queries`,
-              queryIDs: []
-            }
-          )
+          new ProtocolError({
+            kind: error_kind_enum_exports.TransformFailed,
+            origin: error_origin_enum_exports.ZeroCache,
+            reason: error_reason_enum_exports.Internal,
+            message: `Unknown error transforming queries: ${JSON.stringify(error)}`,
+            queryIDs: []
+          })
         );
       }
     }
@@ -16391,13 +16576,17 @@ function rafFallback(callback) {
 }
 
 // ../zero-client/src/client/zero-rep.ts
+var REPLICACHE_NO_AUTH_TOKEN = "";
+var toReplicacheAuthToken = (auth) => auth ?? REPLICACHE_NO_AUTH_TOKEN;
+var fromReplicacheAuthToken = (auth) => !auth ? void 0 : auth;
 var ZeroRep = class {
   #context;
   #ivmMain;
   #customMutatorsEnabled;
   #mutationTracker;
   #store;
-  #auth;
+  // matches replicache's auth token type
+  #auth = REPLICACHE_NO_AUTH_TOKEN;
   constructor(context, ivmMain, customMutatorsEnabled, mutationTracker) {
     this.#context = context;
     this.#ivmMain = ivmMain;
@@ -16405,11 +16594,7 @@ var ZeroRep = class {
     this.#mutationTracker = mutationTracker;
   }
   set auth(auth) {
-    if (auth === "") {
-      this.#auth = void 0;
-    } else {
-      this.#auth = auth;
-    }
+    this.#auth = auth;
   }
   async init(hash, store) {
     const diffs = [];
@@ -16435,7 +16620,7 @@ var ZeroRep = class {
     }
     return this.#ivmMain.forkToHead(must(this.#store), desiredHead, readOptions).then((branch) => ({
       ivmSources: branch,
-      token: this.#auth
+      token: fromReplicacheAuthToken(this.#auth)
     }));
   };
   advance = (expectedHash, newHash, diffs) => {
@@ -16561,6 +16746,7 @@ var Zero = class _Zero {
   #visibilityWatcher;
   #connectionManager;
   #connection;
+  #unsubscribeConnectionState = void 0;
   #activeClientsManager;
   #inspector;
   #connectStart = void 0;
@@ -16637,6 +16823,11 @@ var Zero = class _Zero {
     this.#connectionManager = new ConnectionManager({
       disconnectTimeoutMs: DEFAULT_DISCONNECT_TIMEOUT_MS
     });
+    const syncOnlineState = (state) => {
+      this.#onlineManager.setOnline(state.name === connection_status_enum_exports.Connected);
+    };
+    syncOnlineState(this.#connectionManager.state);
+    this.#unsubscribeConnectionState = this.#connectionManager.subscribe(syncOnlineState);
     const { enableLegacyMutators = true, enableLegacyQueries = true } = schema;
     const replicacheMutators = {
       [CRUD_MUTATION_NAME]: enableLegacyMutators ? makeCRUDMutator(schema) : () => Promise.reject(
@@ -16779,7 +16970,11 @@ var Zero = class _Zero {
     this.#server = server;
     this.userID = userID;
     this.#lc = lc.withContext("clientID", rep.clientID);
-    this.#connection = new ConnectionImpl(this.#connectionManager, this.#lc);
+    this.#connection = new ConnectionImpl(
+      this.#connectionManager,
+      this.#lc,
+      (auth) => this.#setAuth(auth)
+    );
     this.#mutationTracker.setClientIDAndWatch(
       rep.clientID,
       rep.experimentalWatch.bind(rep)
@@ -17086,6 +17281,8 @@ var Zero = class _Zero {
         return;
       }
       lc.debug?.("Closing Zero instance. Stack:", new Error().stack);
+      this.#unsubscribeConnectionState?.();
+      this.#unsubscribeConnectionState = void 0;
       this.#onlineManager.cleanup();
       if (!this.#connectionManager.is(connection_status_enum_exports.Disconnected)) {
         this.#disconnect(
@@ -17346,15 +17543,19 @@ ${error.errorBody.message}`, error);
    * attempt times out.
    */
   async #connect(lc, additionalConnectParams) {
-    assert(this.#server);
+    if (this.closed) {
+      return;
+    }
+    assert(this.#server, "No server provided");
     assert(
-      this.#connectionManager.is(connection_status_enum_exports.Disconnected) || this.#connectionManager.is(connection_status_enum_exports.Connecting)
+      this.#connectionManager.is(connection_status_enum_exports.Disconnected) || this.#connectionManager.is(connection_status_enum_exports.Connecting),
+      "connect() called from invalid state: " + this.#connectionManager.state.name
     );
     const wsid = nanoid();
     lc = addWebSocketIDToLogContext(wsid, lc);
     lc.info?.("Connecting...", { navigatorOnline: localNavigator?.onLine });
     this.#connectionManager.connecting();
-    assert(this.#connectStart === void 0);
+    assert(this.#connectStart === void 0, "connect start time is defined");
     const now = Date.now();
     this.#connectStart = now;
     if (this.#totalToConnectStart === void 0) {
@@ -17394,7 +17595,7 @@ ${error.errorBody.message}`, error);
       await this.clientGroupID,
       this.#clientSchema,
       this.userID,
-      this.#rep.auth,
+      fromReplicacheAuthToken(this.#rep.auth),
       this.#lastMutationIDReceived,
       wsid,
       this.#options.logLevel === "debug",
@@ -17465,6 +17666,7 @@ ${error.errorBody.message}`, error);
         return;
       case connection_status_enum_exports.Disconnected:
       case connection_status_enum_exports.Connecting:
+      case connection_status_enum_exports.NeedsAuth:
       case connection_status_enum_exports.Error:
         break;
       default:
@@ -17485,6 +17687,9 @@ ${error.errorBody.message}`, error);
     this.#pokeHandler.handleDisconnect();
     const transition = getErrorConnectionTransition(reason);
     switch (transition.status) {
+      case connection_status_enum_exports.NeedsAuth:
+        this.#connectionManager.needsAuth(transition.reason);
+        break;
       case connection_status_enum_exports.Error:
         this.#connectionManager.error(transition.reason);
         break;
@@ -17605,14 +17810,6 @@ ${error.errorBody.message}`, error);
       }
     };
   }
-  async #updateAuthToken(lc, error) {
-    const { auth: authOption } = this.#options;
-    const auth = await (typeof authOption === "function" ? authOption(error) : authOption);
-    if (auth) {
-      lc.debug?.("Got auth token");
-      this.#rep.auth = auth;
-    }
-  }
   async #runLoop() {
     this.#lc.info?.(`Starting Zero version: ${this.version}`);
     if (this.#server === null) {
@@ -17634,9 +17831,8 @@ ${error.errorBody.message}`, error);
       }
       return lc.withContext("runLoopCounter", runLoopCounter);
     };
-    await this.#updateAuthToken(bareLogContext);
-    let needsReauth = false;
-    let lastReauthAttemptAt;
+    const { auth } = this.#options;
+    this.#setAuth(auth);
     let backoffMs;
     let additionalConnectParams;
     while (this.#connectionManager.shouldContinueRunLoop()) {
@@ -17660,10 +17856,6 @@ ${error.errorBody.message}`, error);
               throwIfConnectionError(visibilityResult.result);
               break;
             }
-            if (needsReauth) {
-              lastReauthAttemptAt = Date.now();
-              await this.#updateAuthToken(lc, "invalid-token");
-            }
             if (reloadScheduled()) {
               break;
             }
@@ -17673,8 +17865,6 @@ ${error.errorBody.message}`, error);
             assert(this.#socket);
             lc = getLogContext();
             lc.debug?.("Connected successfully");
-            needsReauth = false;
-            this.#setOnline(true);
             break;
           }
           case connection_status_enum_exports.Connected: {
@@ -17703,7 +17893,6 @@ ${error.errorBody.message}`, error);
                   message: "Connection closed because tab was hidden"
                 });
                 this.#disconnect(lc, hiddenError);
-                this.#setOnline(false);
                 break;
               }
               case "stateChange":
@@ -17714,6 +17903,14 @@ ${error.errorBody.message}`, error);
             }
             break;
           }
+          case connection_status_enum_exports.NeedsAuth: {
+            lc.info?.(
+              `Run loop paused in needs-auth state. Call zero.connection.connect({auth}) to resume.`,
+              currentState.reason
+            );
+            await this.#connectionManager.waitForStateChange();
+            break;
+          }
           case connection_status_enum_exports.Error: {
             lc.info?.(
               `Run loop paused in error state. Call zero.connection.connect() to resume.`,
@@ -17757,15 +17954,6 @@ ${error.errorBody.message}`, error);
               }
               additionalConnectParams = backoffParams.reconnectParams;
             }
-            if (isAuthError(transition.reason)) {
-              const now = Date.now();
-              const msSinceLastReauthAttempt = lastReauthAttemptAt === void 0 ? Number.POSITIVE_INFINITY : now - lastReauthAttemptAt;
-              needsReauth = true;
-              if (msSinceLastReauthAttempt > RUN_LOOP_INTERVAL_MS) {
-                continue;
-              }
-            }
-            this.#setOnline(false);
             lc.debug?.(
               "Sleeping",
               backoffMs,
@@ -17775,19 +17963,23 @@ ${error.errorBody.message}`, error);
             await sleep(backoffMs);
             break;
           }
+          case connection_status_enum_exports.NeedsAuth: {
+            lc.debug?.(
+              "Auth error encountered, transitioning to needs-auth state"
+            );
+            this.#connectionManager.needsAuth(transition.reason);
+            break;
+          }
           case connection_status_enum_exports.Error: {
             lc.debug?.("Fatal error encountered, transitioning to error state");
-            this.#setOnline(false);
             this.#connectionManager.error(transition.reason);
             break;
           }
           case connection_status_enum_exports.Disconnected: {
-            this.#setOnline(false);
             this.#connectionManager.disconnected(transition.reason);
             break;
           }
           case connection_status_enum_exports.Closed: {
-            this.#setOnline(false);
             break;
           }
           default:
@@ -17868,8 +18060,13 @@ ${error.errorBody.message}`, error);
       this.#pendingPullsByRequestID.delete(requestID);
     }
   }
-  #setOnline(online) {
-    this.#onlineManager.setOnline(online);
+  /**
+   * Sets the authentication token on the replicache instance.
+   *
+   * @param auth - The authentication token to set.
+   */
+  #setAuth(auth) {
+    this.#rep.auth = toReplicacheAuthToken(auth);
   }
   /**
    * A rough heuristic for whether the client is currently online and
@@ -18110,6 +18307,7 @@ export {
   dropDatabase,
   dropAllDatabases,
   TransactionClosedError,
+  ApplicationError,
   error_kind_enum_exports,
   error_origin_enum_exports,
   error_reason_enum_exports,
@@ -18117,7 +18315,7 @@ export {
   transformResponseMessageSchema,
   table,
   string4 as string,
-  number4 as number,
+  number3 as number,
   boolean,
   json,
   enumeration,
@@ -18136,4 +18334,4 @@ export {
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-AIPM77UE.js.map
+//# sourceMappingURL=chunk-QZSBDHTA.js.map