@rocicorp/zero 0.11.2025011802 → 0.11.2025012400

package/out/{chunk-3JROCHFI.js → chunk-N57WXYAL.js}

@@ -896,6 +896,7 @@ function dropIDBStore(name) {
 }
 
 // ../replicache/src/replicache-impl.ts
+import { Lock as Lock2 } from "@rocicorp/lock";
 import { consoleLogSink as consoleLogSink2 } from "@rocicorp/logger";
 import { resolver as resolver6 } from "@rocicorp/resolver";
 
@@ -5111,7 +5112,6 @@ function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID,
         );
       }
       if (Object.keys(response.lastMutationIDChanges).length > 0) {
-        console.log(response.lastMutationIDChanges);
         lc.error?.(
           `handlePullResponse: cookie ${JSON.stringify(
             baseCookie
@@ -7151,14 +7151,8 @@ function getSessionID() {
 }
 var REQUEST_COUNTERS = /* @__PURE__ */ new Map();
 function newRequestID(clientID) {
-  let counter = REQUEST_COUNTERS.get(clientID);
-  if (!counter) {
-    REQUEST_COUNTERS.set(clientID, 0);
-    counter = 0;
-  } else {
-    counter++;
-    REQUEST_COUNTERS.set(clientID, counter);
-  }
+  const counter = REQUEST_COUNTERS.get(clientID) ?? 0;
+  REQUEST_COUNTERS.set(clientID, counter + 1);
   return `${clientID}-${getSessionID()}-${counter}`;
 }
 
@@ -7254,7 +7248,7 @@ var ReplicacheImpl = class {
   #idbDatabases;
   #lc;
   #closeAbortController = new AbortController();
-  #persistIsRunning = false;
+  #persistLock = new Lock2();
   #enableScheduledPersist;
   #enableScheduledRefresh;
   #enablePullAndPushInOpen;
@@ -7946,11 +7940,9 @@ var ReplicacheImpl = class {
     const { syncHead, httpRequestInfo } = beginPullResponse;
     return { requestID, syncHead, ok: httpRequestInfo.httpStatusCode === 200 };
   }
-  async persist() {
-    assert(!this.#persistIsRunning);
-    this.#persistIsRunning = true;
-    try {
-      const { clientID: clientID2 } = this;
+  persist() {
+    return this.#persistLock.withLock(async () => {
+      const { clientID } = this;
       await this.#ready;
       if (this.#closed) {
         return;
@@ -7958,29 +7950,26 @@ var ReplicacheImpl = class {
       try {
         await persistDD31(
           this.#lc,
-          clientID2,
+          clientID,
           this.memdag,
           this.perdag,
           this.#mutatorRegistry,
-          () => this.closed,
+          () => this.#closed,
           Latest
         );
       } catch (e) {
         if (e instanceof ClientStateNotFoundError) {
-          this.#clientStateNotFoundOnClient(clientID2);
+          this.#clientStateNotFoundOnClient(clientID);
         } else if (this.#closed) {
           this.#lc.debug?.("Exception persisting during close", e);
         } else {
           throw e;
         }
       }
-    } finally {
-      this.#persistIsRunning = false;
-    }
-    const { clientID } = this;
-    const clientGroupID = await this.#clientGroupIDPromise;
-    assert(clientGroupID);
-    this.#onPersist({ clientID, clientGroupID });
+      const clientGroupID = await this.#clientGroupIDPromise;
+      assert(clientGroupID);
+      this.#onPersist({ clientID, clientGroupID });
+    });
   }
   async refresh() {
     await this.#ready;
@@ -8320,6 +8309,176 @@ function getKVStoreProvider(lc, kvStore) {
 // ../replicache/src/mod.ts
 import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
 
+// ../zero-schema/src/builder/relationship-builder.ts
+function relationships(table2, cb) {
+  const relationships2 = cb({ many, one });
+  return {
+    name: table2.schema.name,
+    relationships: relationships2
+  };
+}
+function many(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "many"
+  }));
+}
+function one(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "one"
+  }));
+}
+
+// ../zero-schema/src/builder/table-builder.ts
+function table(name) {
+  return new TableBuilder({
+    name,
+    columns: {},
+    primaryKey: []
+  });
+}
+function string7() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+function number4() {
+  return new ColumnBuilder({
+    type: "number",
+    optional: false,
+    customType: null
+  });
+}
+function boolean3() {
+  return new ColumnBuilder({
+    type: "boolean",
+    optional: false,
+    customType: null
+  });
+}
+function json() {
+  return new ColumnBuilder({
+    type: "json",
+    optional: false,
+    customType: null
+  });
+}
+function enumeration() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+var TableBuilder = class {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  columns(columns) {
+    const columnSchemas = Object.fromEntries(
+      Object.entries(columns).map(([k, v2]) => [k, v2.schema])
+    );
+    return new TableBuilderWithColumns({
+      ...this.#schema,
+      columns: columnSchemas
+    });
+  }
+};
+var TableBuilderWithColumns = class _TableBuilderWithColumns {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  primaryKey(...pkColumnNames) {
+    return new _TableBuilderWithColumns({
+      ...this.#schema,
+      primaryKey: pkColumnNames
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+  build() {
+    if (this.#schema.primaryKey.length === 0) {
+      throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
+    }
+    return this.#schema;
+  }
+};
+var ColumnBuilder = class _ColumnBuilder {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  optional() {
+    return new _ColumnBuilder({
+      ...this.#schema,
+      optional: true
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+};
+
+// ../zero-schema/src/builder/schema-builder.ts
+function createSchema(version3, options) {
+  const retTables = {};
+  const retRelationships = {};
+  options.tables.forEach((table2) => {
+    if (retTables[table2.schema.name]) {
+      throw new Error(
+        `Table "${table2.schema.name}" is defined more than once in the schema`
+      );
+    }
+    retTables[table2.schema.name] = table2.build();
+  });
+  options.relationships?.forEach((relationships2) => {
+    if (retRelationships[relationships2.name]) {
+      throw new Error(
+        `Relationships for table "${relationships2.name}" are defined more than once in the schema`
+      );
+    }
+    retRelationships[relationships2.name] = relationships2.relationships;
+    checkRelationship(
+      relationships2.relationships,
+      relationships2.name,
+      retTables
+    );
+  });
+  return {
+    version: version3,
+    tables: retTables,
+    relationships: retRelationships
+  };
+}
+function checkRelationship(relationships2, tableName, tables) {
+  Object.entries(relationships2).forEach(([name, rel]) => {
+    let source = tables[tableName];
+    rel.forEach((connection) => {
+      if (!tables[connection.destSchema]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", destination table "${connection.destSchema}" is missing in the schema`
+        );
+      }
+      if (!source.columns[connection.sourceField[0]]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", the source field "${connection.sourceField[0]}" is missing in the table schema "${source.name}"`
+        );
+      }
+      source = tables[connection.destSchema];
+    });
+  });
+}
+
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
@@ -8400,8 +8559,13 @@ var columnReferenceSchema = readonlyObject({
 });
 var parameterReferenceSchema = readonlyObject({
   type: valita_exports.literal("static"),
+  // The "namespace" of the injected parameter.
+  // Write authorization will send the value of a row
+  // prior to the mutation being run (preMutationRow).
+  // Read and write authorization will both send the
+  // current authentication data (authData).
   anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
-  field: valita_exports.string()
+  field: valita_exports.union(valita_exports.string(), valita_exports.array(valita_exports.string()))
 });
 var conditionValueSchema = valita_exports.union(
   literalReferenceSchema,
@@ -9207,15 +9371,39 @@ function maybeSplitAndPushEditChange(change, predicate, output) {
   }
 }
 
+// ../zql/src/ivm/filter-push.ts
+function filterPush(change, output, predicate) {
+  if (!predicate) {
+    output.push(change);
+    return;
+  }
+  switch (change.type) {
+    case "add":
+    case "remove":
+      if (predicate(change.node.row)) {
+        output.push(change);
+      }
+      break;
+    case "child":
+      if (predicate(change.row)) {
+        output.push(change);
+      }
+      break;
+    case "edit":
+      maybeSplitAndPushEditChange(change, predicate, output);
+      break;
+    default:
+      unreachable(change);
+  }
+}
+
 // ../zql/src/ivm/filter.ts
 var Filter = class {
   #input;
-  #mode;
   #predicate;
   #output = throwOutput;
-  constructor(input, mode, predicate) {
+  constructor(input, predicate) {
     this.#input = input;
-    this.#mode = mode;
     this.#predicate = predicate;
     input.setOutput(this);
   }
@@ -9236,30 +9424,13 @@ var Filter = class {
   }
   *#filter(stream) {
     for (const node of stream) {
-      if (this.#mode === "push-only" || this.#predicate(node.row)) {
+      if (this.#predicate(node.row)) {
         yield node;
       }
     }
   }
   push(change) {
-    switch (change.type) {
-      case "add":
-      case "remove":
-        if (this.#predicate(change.node.row)) {
-          this.#output.push(change);
-        }
-        break;
-      case "child":
-        if (this.#predicate(change.row)) {
-          this.#output.push(change);
-        }
-        break;
-      case "edit":
-        maybeSplitAndPushEditChange(change, this.#predicate, this.#output);
-        break;
-      default:
-        unreachable(change);
-    }
+    filterPush(change, this.#output, this.#predicate);
   }
 };
 
@@ -10315,7 +10486,7 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   }
   const conn = source.connect(must(ast.orderBy), ast.where);
   let end = conn;
-  const { appliedFilters } = conn;
+  const { fullyAppliedFilters } = conn;
   ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
   if (ast.start) {
     end = new Skip(end, ast.start);
@@ -10323,8 +10494,8 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
     end = applyCorrelatedSubQuery(csq, delegate, end);
   }
-  if (ast.where) {
-    end = applyWhere(end, ast.where, appliedFilters, delegate);
+  if (ast.where && !fullyAppliedFilters) {
+    end = applyWhere(end, ast.where, delegate);
   }
   if (ast.limit) {
     end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
@@ -10336,45 +10507,43 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   }
   return end;
 }
-function applyWhere(input, condition, appliedFilters, delegate) {
+function applyWhere(input, condition, delegate) {
   switch (condition.type) {
     case "and":
-      return applyAnd(input, condition, appliedFilters, delegate);
+      return applyAnd(input, condition, delegate);
     case "or":
-      return applyOr(input, condition, appliedFilters, delegate);
+      return applyOr(input, condition, delegate);
     case "correlatedSubquery":
       return applyCorrelatedSubqueryCondition(input, condition, delegate);
     case "simple":
-      return applySimpleCondition(input, condition, appliedFilters);
+      return applySimpleCondition(input, condition);
   }
 }
-function applyAnd(input, condition, appliedFilters, delegate) {
+function applyAnd(input, condition, delegate) {
   for (const subCondition of condition.conditions) {
-    input = applyWhere(input, subCondition, appliedFilters, delegate);
+    input = applyWhere(input, subCondition, delegate);
   }
   return input;
 }
-function applyOr(input, condition, appliedFilters, delegate) {
+function applyOr(input, condition, delegate) {
   const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
   if (subqueryConditions.length === 0) {
-    return otherConditions.length > 0 ? new Filter(
+    return new Filter(
       input,
-      appliedFilters ? "push-only" : "all",
       createPredicate({
         type: "or",
         conditions: otherConditions
       })
-    ) : new FanIn(new FanOut(input), []);
+    );
   }
   const fanOut = new FanOut(input);
   const branches = subqueryConditions.map(
-    (subCondition) => applyWhere(fanOut, subCondition, appliedFilters, delegate)
+    (subCondition) => applyWhere(fanOut, subCondition, delegate)
   );
   if (otherConditions.length > 0) {
     branches.push(
       new Filter(
         fanOut,
-        appliedFilters ? "push-only" : "all",
         createPredicate({
           type: "or",
           conditions: otherConditions
@@ -10405,12 +10574,8 @@ function isNotAndDoesNotContainSubquery(condition) {
   assert(condition.type !== "or", "where conditions are expected to be in DNF");
   return true;
 }
-function applySimpleCondition(input, condition, appliedFilters) {
-  return new Filter(
-    input,
-    appliedFilters ? "push-only" : "all",
-    createPredicate(condition)
-  );
+function applySimpleCondition(input, condition) {
+  return new Filter(input, createPredicate(condition));
 }
 function applyCorrelatedSubQuery(sq, delegate, end) {
   assert(sq.subquery.alias, "Subquery must have an alias");
@@ -10871,7 +11036,9 @@ var AbstractQuery = class {
   where(fieldOrExpressionFactory, opOrValue, value) {
     let cond;
     if (typeof fieldOrExpressionFactory === "function") {
-      cond = fieldOrExpressionFactory(new ExpressionBuilder(this._exists));
+      cond = fieldOrExpressionFactory(
+        new ExpressionBuilder(this._exists)
+      );
     } else {
       assert(opOrValue !== void 0, "Invalid condition");
       cond = cmp(fieldOrExpressionFactory, opOrValue, value);
@@ -11298,162 +11465,6 @@ function baseTracker(anchor) {
 var authDataRef = baseTracker("authData");
 var preMutationRowRef = baseTracker("preMutationRow");
 
-// ../zero-schema/src/builder/table-builder.ts
-function table(name) {
-  return new TableBuilder({
-    name,
-    columns: {},
-    primaryKey: []
-  });
-}
-function string8() {
-  return new ColumnBuilder({
-    type: "string",
-    optional: false,
-    customType: null
-  });
-}
-function number5() {
-  return new ColumnBuilder({
-    type: "number",
-    optional: false,
-    customType: null
-  });
-}
-function boolean4() {
-  return new ColumnBuilder({
-    type: "boolean",
-    optional: false,
-    customType: null
-  });
-}
-function json() {
-  return new ColumnBuilder({
-    type: "json",
-    optional: false,
-    customType: null
-  });
-}
-function enumeration() {
-  return new ColumnBuilder({
-    type: "string",
-    optional: false,
-    customType: null
-  });
-}
-var TableBuilder = class {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  columns(columns) {
-    const columnSchemas = Object.fromEntries(
-      Object.entries(columns).map(([k, v2]) => [k, v2.schema])
-    );
-    return new TableBuilderWithColumns({
-      ...this.#schema,
-      columns: columnSchemas
-    });
-  }
-};
-var TableBuilderWithColumns = class _TableBuilderWithColumns {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  primaryKey(...pkColumnNames) {
-    return new _TableBuilderWithColumns({
-      ...this.#schema,
-      primaryKey: pkColumnNames
-    });
-  }
-  get schema() {
-    return this.#schema;
-  }
-  build() {
-    if (this.#schema.primaryKey.length === 0) {
-      throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
-    }
-    return this.#schema;
-  }
-};
-var ColumnBuilder = class _ColumnBuilder {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  optional() {
-    return new _ColumnBuilder({
-      ...this.#schema,
-      optional: true
-    });
-  }
-  get schema() {
-    return this.#schema;
-  }
-};
-
-// ../zero-schema/src/builder/schema-builder.ts
-function createSchema(version3, tables, relationships2) {
-  const retTables = {};
-  const retRelationships = {};
-  Object.values(tables).forEach((table2) => {
-    retTables[table2.schema.name] = table2.build();
-  });
-  Object.values(relationships2 ?? {}).forEach((relationship) => {
-    retRelationships[relationship.name] = relationship.relationships;
-    checkRelationship(relationship.relationships, relationship.name, retTables);
-  });
-  return {
-    version: version3,
-    tables: retTables,
-    relationships: retRelationships
-  };
-}
-function checkRelationship(relationships2, tableName, tables) {
-  Object.entries(relationships2).forEach(([name, rel]) => {
-    let source = tables[tableName];
-    rel.forEach((connection) => {
-      if (!tables[connection.destSchema]) {
-        throw new Error(
-          `For relationship "${tableName}"."${name}", destination table "${connection.destSchema}" is missing in the schema`
-        );
-      }
-      if (!source.columns[connection.sourceField[0]]) {
-        throw new Error(
-          `For relationship "${tableName}"."${name}", the source field "${connection.sourceField[0]}" is missing in the table schema "${source.name}"`
-        );
-      }
-      source = tables[connection.destSchema];
-    });
-  });
-}
-
-// ../zero-schema/src/builder/relationship-builder.ts
-function relationships(table2, cb) {
-  const relationships2 = cb({ many, one });
-  return {
-    name: table2.schema.name,
-    relationships: relationships2
-  };
-}
-function many(...args) {
-  return args.map((arg) => ({
-    sourceField: arg.sourceField,
-    destField: arg.destField,
-    destSchema: arg.destSchema.schema.name,
-    cardinality: "many"
-  }));
-}
-function one(...args) {
-  return args.map((arg) => ({
-    sourceField: arg.sourceField,
-    destField: arg.destField,
-    destSchema: arg.destSchema.schema.name,
-    cardinality: "one"
-  }));
-}
-
 // ../zql/src/query/escape-like.ts
 function escapeLike(val) {
   return val.replace(/[%_]/g, "\\$&");
@@ -11474,6 +11485,8 @@ var InvalidMessage = "InvalidMessage";
 var InvalidPush = "InvalidPush";
 var MutationFailed = "MutationFailed";
 var MutationRateLimited = "MutationRateLimited";
+var Rebalance = "Rebalance";
+var Rehome = "Rehome";
 var Unauthorized = "Unauthorized";
 var VersionNotSupported = "VersionNotSupported";
 var SchemaVersionNotSupported = "SchemaVersionNotSupported";
@@ -11545,7 +11558,7 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
 }
 
 // ../zero-protocol/src/error.ts
-var errorKindSchema = valita_exports.union(
+var basicErrorKindSchema = valita_exports.union(
   valita_exports.literal(AuthInvalidated),
   valita_exports.literal(ClientNotFound),
   valita_exports.literal(InvalidConnectionRequest),
@@ -11562,18 +11575,29 @@ var errorKindSchema = valita_exports.union(
   valita_exports.literal(Internal)
 );
 var basicErrorBodySchema = valita_exports.object({
-  kind: errorKindSchema,
+  kind: basicErrorKindSchema,
   message: valita_exports.string()
 });
-var serverOverloadedBodySchema = valita_exports.object({
-  kind: valita_exports.literal(ServerOverloaded),
+var backoffErrorKindSchema = valita_exports.union(
+  valita_exports.literal(Rebalance),
+  valita_exports.literal(Rehome),
+  valita_exports.literal(ServerOverloaded)
+);
+var backoffBodySchema = valita_exports.object({
+  kind: backoffErrorKindSchema,
   message: valita_exports.string(),
-  minBackoffMs: valita_exports.number().optional()
+  minBackoffMs: valita_exports.number().optional(),
+  maxBackoffMs: valita_exports.number().optional(),
+  // Query parameters to send in the next reconnect. In the event of
+  // a conflict, these will be overridden by the parameters used by
+  // the client; it is the responsibility of the server to avoid
+  // parameter name conflicts.
+  //
+  // The parameters will only be added to the immediately following
+  // reconnect, and not after that.
+  reconnectParams: valita_exports.record(valita_exports.string()).optional()
 });
-var errorBodySchema = valita_exports.union(
-  basicErrorBodySchema,
-  serverOverloadedBodySchema
-);
+var errorBodySchema = valita_exports.union(basicErrorBodySchema, backoffBodySchema);
 var errorMessageSchema = valita_exports.tuple([
   valita_exports.literal("error"),
   errorBodySchema
@@ -11815,7 +11839,7 @@ var upstreamSchema = valita_exports.union(
 );
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 3;
+var PROTOCOL_VERSION = 4;
 var MIN_SERVER_SUPPORTED_PROTOCOL_VERSION = 2;
 assert(MIN_SERVER_SUPPORTED_PROTOCOL_VERSION < PROTOCOL_VERSION);
 
@@ -12398,8 +12422,8 @@ var MemorySource = class {
       compareRows: connection.compareRows
     };
   }
-  connect(sort, optionalFilters) {
-    const transformedFilters = transformFilters(optionalFilters);
+  connect(sort, filters) {
+    const transformedFilters = transformFilters(filters);
     const input = {
       getSchema: () => schema,
       fetch: (req) => this.#fetch(req, connection),
@@ -12410,7 +12434,7 @@ var MemorySource = class {
       destroy: () => {
         this.#disconnect(input);
       },
-      appliedFilters: !transformedFilters.conditionsRemoved
+      fullyAppliedFilters: !transformedFilters.conditionsRemoved
     };
     const connection = {
       input,
@@ -12572,10 +12596,13 @@ var MemorySource = class {
         relationships: {}
       }
     };
-    for (const [outputIndex, { output }] of this.#connections.entries()) {
+    for (const [
+      outputIndex,
+      { output, filters }
+    ] of this.#connections.entries()) {
       if (output) {
         this.#overlay = { outputIndex, change };
-        output.push(outputChange);
+        filterPush(outputChange, output, filters?.predicate);
         yield;
       }
     }
@@ -13179,7 +13206,7 @@ import {
 } from "@rocicorp/logger";
 
 // ../datadog/src/datadog-log-sink.ts
-import { Lock as Lock2 } from "@rocicorp/lock";
+import { Lock as Lock3 } from "@rocicorp/lock";
 var DD_BASE_URL = new URL(
   "https://http-intake.logs.datadoghq.com/api/v2/logs"
 );
@@ -13198,7 +13225,7 @@ var DatadogLogSink = class {
   #interval;
   #baseURL;
   #timerID = 0;
-  #flushLock = new Lock2();
+  #flushLock = new Lock3();
   constructor(options) {
     const {
       apiKey,
@@ -13397,7 +13424,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.11.2025011802+b8c880";
+var version2 = "0.11.2025012400+d6c57e";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -13951,8 +13978,16 @@ function isAuthError(ex) {
 function isAuthErrorKind(kind) {
   return kind === AuthInvalidated || kind === Unauthorized;
 }
-function isServerOverloadedError(ex) {
-  return isServerError(ex) && ex.errorBody.kind === ServerOverloaded ? ex.errorBody : void 0;
+function isBackoffError(ex) {
+  if (isServerError(ex)) {
+    switch (ex.errorBody.kind) {
+      case Rebalance:
+      case Rehome:
+      case ServerOverloaded:
+        return ex.errorBody;
+    }
+  }
+  return void 0;
 }
 
 // ../zero-client/src/client/server-option.ts
@@ -14017,7 +14052,7 @@ function getServer(server) {
 }
 
 // ../zero-client/src/client/zero-poke-handler.ts
-import { Lock as Lock3 } from "@rocicorp/lock";
+import { Lock as Lock4 } from "@rocicorp/lock";
 var PokeHandler = class {
   #replicachePoke;
   #onPokeError;
@@ -14029,7 +14064,7 @@ var PokeHandler = class {
   #lastRafPerfTimestamp = 0;
   // Serializes calls to this.#replicachePoke otherwise we can cause out of
   // order poke errors.
-  #pokeLock = new Lock3();
+  #pokeLock = new Lock4();
   #schema;
   #raf = getBrowserGlobalMethod("requestAnimationFrame") ?? rafFallback;
   constructor(replicachePoke, onPokeError, clientID, schema, lc) {
@@ -14860,7 +14895,7 @@ var Zero = class {
    * is received before the connected message is received or if the connection
    * attempt times out.
    */
-  async #connect(l) {
+  async #connect(l, additionalConnectParams) {
     assert(this.#server);
     assert(this.#connectionState === Disconnected);
     const wsid = nanoid();
@@ -14908,7 +14943,8 @@ var Zero = class {
       wsid,
       this.#options.logLevel === "debug",
       l,
-      this.#options.maxHeaderLength
+      this.#options.maxHeaderLength,
+      additionalConnectParams
     );
     if (this.closed) {
       return;
@@ -15119,6 +15155,7 @@ var Zero = class {
     let needsReauth = false;
     let gotError = false;
     let backoffMs = RUN_LOOP_INTERVAL_MS;
+    let additionalConnectParams;
     while (!this.closed) {
       runLoopCounter++;
       let lc = getLogContext();
@@ -15137,7 +15174,8 @@ var Zero = class {
             if (reloadScheduled()) {
               break;
             }
-            await this.#connect(lc);
+            await this.#connect(lc, additionalConnectParams);
+            additionalConnectParams = void 0;
             if (this.closed) {
               break;
             }
@@ -15219,9 +15257,15 @@ var Zero = class {
         if (isServerError(ex) || ex instanceof TimedOutError || ex instanceof CloseError) {
           gotError = true;
         }
-        const overloaded = isServerOverloadedError(ex);
-        if (overloaded && overloaded.minBackoffMs) {
-          backoffMs = Math.max(backoffMs, overloaded.minBackoffMs);
+        const backoffError = isBackoffError(ex);
+        if (backoffError) {
+          if (backoffError.minBackoffMs !== void 0) {
+            backoffMs = Math.max(backoffMs, backoffError.minBackoffMs);
+          }
+          if (backoffError.maxBackoffMs !== void 0) {
+            backoffMs = Math.min(backoffMs, backoffError.maxBackoffMs);
+          }
+          additionalConnectParams = backoffError.reconnectParams;
         }
       }
       if (gotError) {
@@ -15361,7 +15405,7 @@ var Zero = class {
     return rv;
   }
 };
-async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8) {
+async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8, additionalConnectParams) {
   const url = new URL(
     appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
   );
@@ -15377,6 +15421,15 @@ async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientI
   if (debugPerf) {
     searchParams.set("debugPerf", true.toString());
   }
+  if (additionalConnectParams) {
+    for (const k in additionalConnectParams) {
+      if (searchParams.has(k)) {
+        lc.warn?.(`skipping conflicting parameter ${k}`);
+      } else {
+        searchParams.set(k, additionalConnectParams[k]);
+      }
+    }
+  }
   lc.info?.("Connecting to", url.toString());
   const WS = mustGetBrowserGlobal("WebSocket");
   let queriesPatch = await rep.query(
@@ -15424,18 +15477,18 @@ export {
   makeIDBName,
   dropDatabase,
   dropAllDatabases,
-  ANYONE_CAN,
-  NOBODY_CAN,
-  definePermissions,
+  relationships,
   table,
-  string8 as string,
-  number5 as number,
-  boolean4 as boolean,
+  string7 as string,
+  number4 as number,
+  boolean3 as boolean,
   json,
   enumeration,
   createSchema,
-  relationships,
+  ANYONE_CAN,
+  NOBODY_CAN,
+  definePermissions,
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-3JROCHFI.js.map
+//# sourceMappingURL=chunk-N57WXYAL.js.map