@rocicorp/zero 0.24.2025102100 → 0.25.0-canary.0

package/out/{chunk-TA2NZPJQ.js → chunk-MXPHMVU7.js}

@@ -123,7 +123,7 @@ import {
   withWrite,
   withWriteNoImplicitCommit,
   wrapIterable
-} from "./chunk-VHLCXJ6Q.js";
+} from "./chunk-4RB4OYLQ.js";
 import {
   assert,
   assertArray,
@@ -2185,7 +2185,7 @@ var SchemaVersionNotSupported2 = "SchemaVersionNotSupported";
 
 // ../zero-client/src/client/zero.ts
 import "@rocicorp/logger";
-import { resolver as resolver10 } from "@rocicorp/resolver";
+import { resolver as resolver11 } from "@rocicorp/resolver";
 
 // ../replicache/src/replicache-impl.ts
 import { Lock } from "@rocicorp/lock";
@@ -9672,12 +9672,36 @@ function buildPipeline(ast, delegate, queryID) {
 }
 var EXISTS_LIMIT = 3;
 var PERMISSIONS_EXISTS_LIMIT = 1;
+function assertNoNotExists(condition) {
+  switch (condition.type) {
+    case "simple":
+      return;
+    case "correlatedSubquery":
+      if (condition.op === "NOT EXISTS") {
+        throw new Error(
+          "not(exists()) is not supported on the client - see https://bugs.rocicorp.dev/issue/3438"
+        );
+      }
+      return;
+    case "and":
+    case "or":
+      for (const c of condition.conditions) {
+        assertNoNotExists(c);
+      }
+      return;
+    default:
+      unreachable(condition);
+  }
+}
 function buildPipelineInternal(ast, delegate, queryID, name, partitionKey) {
   const source = delegate.getSource(ast.table);
   if (!source) {
     throw new Error(`Source not found: ${ast.table}`);
   }
   ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
+  if (!delegate.enableNotExists && ast.where) {
+    assertNoNotExists(ast.where);
+  }
   const csqConditions = gatherCorrelatedSubqueryQueryConditions(ast.where);
   const splitEditKeys = partitionKey ? new Set(partitionKey) : /* @__PURE__ */ new Set();
   const aliases = /* @__PURE__ */ new Set();
@@ -10200,32 +10224,6 @@ var defaultFormat = {
   relationships: {}
 };
 
-// ../zql/src/query/assert-no-not-exists.ts
-function assertNoNotExists(condition) {
-  switch (condition.type) {
-    case "simple":
-      return;
-    case "correlatedSubquery":
-      if (condition.op === "NOT EXISTS") {
-        throw new Error(
-          "not(exists()) is not supported on the client - see https://bugs.rocicorp.dev/issue/3438"
-        );
-      }
-      if (condition.related.subquery.where) {
-        assertNoNotExists(condition.related.subquery.where);
-      }
-      return;
-    case "and":
-    case "or":
-      for (const c of condition.conditions) {
-        assertNoNotExists(c);
-      }
-      return;
-    default:
-      unreachable(condition);
-  }
-}
-
 // ../zql/src/query/query.ts
 var delegateSymbol = Symbol("delegate");
 
@@ -10489,9 +10487,6 @@ var AbstractQuery = class {
       cond = and(existingWhere, cond);
     }
     const where = simplifyCondition(cond);
-    if (this.#system === "client") {
-      assertNoNotExists(where);
-    }
     return this[newQuerySymbol](
       this._delegate,
       this.#schema,
@@ -11099,10 +11094,238 @@ var MockClientLockManager = class {
   }
 };
 
-// ../zero-client/src/client/connection-state-enum.ts
-var Disconnected = 0;
-var Connecting = 1;
-var Connected = 2;
+// ../zero-client/src/client/connection-manager.ts
+import { resolver as resolver9 } from "@rocicorp/resolver";
+
+// ../zero-client/src/client/connection-status-enum.ts
+var connection_status_enum_exports = {};
+__export(connection_status_enum_exports, {
+  Closed: () => Closed,
+  Connected: () => Connected,
+  Connecting: () => Connecting,
+  Disconnected: () => Disconnected
+});
+var Disconnected = "disconnected";
+var Connecting = "connecting";
+var Connected = "connected";
+var Closed = "closed";
+
+// ../zero-client/src/client/connection-manager.ts
+var DEFAULT_TIMEOUT_CHECK_INTERVAL_MS = 1e3;
+var ConnectionManager = class extends Subscribable {
+  #state;
+  /**
+   * The timestamp when we first started trying to connect.
+   * This is used to track the retry window.
+   * Reset to undefined when we successfully connect or when we transition to disconnected.
+   */
+  #connectingStartedAt;
+  /**
+   * The amount of time we allow for continuous connecting attempts before
+   * transitioning to disconnected state.
+   */
+  #disconnectTimeoutMs;
+  /**
+   * Handle for the timeout interval that periodically checks whether we've
+   * exceeded the allowed connecting window.
+   */
+  #timeoutInterval;
+  /**
+   * Interval duration for checking whether the connecting timeout has elapsed.
+   */
+  #timeoutCheckIntervalMs;
+  /**
+   * Resolver used to signal waiting callers when the state changes.
+   */
+  #stateChangeResolver = resolver9();
+  constructor(options) {
+    super();
+    const now = Date.now();
+    this.#disconnectTimeoutMs = options.disconnectTimeoutMs;
+    this.#timeoutCheckIntervalMs = options.timeoutCheckIntervalMs ?? DEFAULT_TIMEOUT_CHECK_INTERVAL_MS;
+    this.#state = {
+      name: connection_status_enum_exports.Connecting,
+      attempt: 0,
+      disconnectAt: now + this.#disconnectTimeoutMs
+    };
+    this.#connectingStartedAt = now;
+    this.#maybeStartTimeoutInterval();
+  }
+  get state() {
+    return this.#state;
+  }
+  /**
+   * Returns true if the current state is equal to the given status.
+   */
+  is(status) {
+    return this.#state.name === status;
+  }
+  /**
+   * Returns true if the run loop should continue.
+   * The run loop continues in disconnected, connecting, and connected states.
+   * It stops in closed state.
+   */
+  shouldContinueRunLoop() {
+    return this.#state.name !== connection_status_enum_exports.Closed;
+  }
+  waitForStateChange() {
+    return this.#nextStatePromise();
+  }
+  /**
+   * Transition to connecting state.
+   *
+   * This starts the 5-minute timeout timer, but if we've entered disconnected state,
+   * we stay there and continue retrying.
+   *
+   * @returns An object containing a promise that resolves on the next state change.
+   */
+  connecting(reason) {
+    if (this.#state.name === connection_status_enum_exports.Closed) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    if (this.#state.name === connection_status_enum_exports.Disconnected) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    const now = Date.now();
+    if (this.#state.name === connection_status_enum_exports.Connecting) {
+      this.#state = {
+        ...this.#state,
+        attempt: this.#state.attempt + 1,
+        reason
+      };
+      const nextStatePromise2 = this.#publishStateAndGetPromise();
+      this.#maybeStartTimeoutInterval();
+      return { nextStatePromise: nextStatePromise2 };
+    }
+    if (this.#connectingStartedAt === void 0) {
+      this.#connectingStartedAt = now;
+    }
+    const disconnectAt = this.#connectingStartedAt + this.#disconnectTimeoutMs;
+    this.#state = {
+      name: connection_status_enum_exports.Connecting,
+      attempt: 1,
+      disconnectAt,
+      reason
+    };
+    const nextStatePromise = this.#publishStateAndGetPromise();
+    this.#maybeStartTimeoutInterval();
+    return { nextStatePromise };
+  }
+  /**
+   * Transition to connected state.
+   * This resets the connecting timeout timer.
+   *
+   * @returns An object containing a promise that resolves on the next state change.
+   */
+  connected() {
+    if (this.#state.name === connection_status_enum_exports.Closed) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    if (this.#state.name === connection_status_enum_exports.Connected) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    this.#connectingStartedAt = void 0;
+    this.#maybeStopTimeoutInterval();
+    this.#state = {
+      name: connection_status_enum_exports.Connected
+    };
+    const nextStatePromise = this.#publishStateAndGetPromise();
+    return { nextStatePromise };
+  }
+  /**
+   * Transition to disconnected state.
+   * This is called when the 5-minute timeout expires, or when we're intentionally
+   * disconnecting due to an error (this will eventually be a separate state, error).
+   * The run loop will continue trying to reconnect.
+   *
+   * @returns An object containing a promise that resolves on the next state change.
+   */
+  disconnected(reason) {
+    if (this.#state.name === connection_status_enum_exports.Closed) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    if (this.#state.name === connection_status_enum_exports.Disconnected) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    if (this.#state.name === connection_status_enum_exports.Connected) {
+      this.#connectingStartedAt = void 0;
+    }
+    this.#maybeStopTimeoutInterval();
+    this.#state = {
+      name: connection_status_enum_exports.Disconnected,
+      reason
+    };
+    const nextStatePromise = this.#publishStateAndGetPromise();
+    return { nextStatePromise };
+  }
+  /**
+   * Transition to closed state.
+   * This is terminal - no further transitions are allowed.
+   *
+   * @returns An object containing a promise that resolves on the next state change.
+   */
+  closed() {
+    if (this.#state.name === connection_status_enum_exports.Closed) {
+      return { nextStatePromise: this.#nextStatePromise() };
+    }
+    this.#connectingStartedAt = void 0;
+    this.#maybeStopTimeoutInterval();
+    this.#state = {
+      name: connection_status_enum_exports.Closed
+    };
+    const nextStatePromise = this.#publishStateAndGetPromise();
+    return { nextStatePromise };
+  }
+  cleanup = () => {
+    this._listeners.clear();
+    this.#resolveNextStateWaiters();
+  };
+  #resolveNextStateWaiters() {
+    this.#stateChangeResolver.resolve();
+    this.#stateChangeResolver = resolver9();
+  }
+  #publishState() {
+    this.notify(this.#state);
+    this.#resolveNextStateWaiters();
+  }
+  #nextStatePromise() {
+    return this.#stateChangeResolver.promise;
+  }
+  #publishStateAndGetPromise() {
+    this.#publishState();
+    return this.#nextStatePromise();
+  }
+  /**
+   * Check if we should transition from connecting to disconnected due to timeout.
+   * Returns true if the transition happened.
+   */
+  #checkTimeout() {
+    if (this.#state.name !== connection_status_enum_exports.Connecting) {
+      return false;
+    }
+    const now = Date.now();
+    if (now >= this.#state.disconnectAt) {
+      this.disconnected();
+      return true;
+    }
+    return false;
+  }
+  #maybeStartTimeoutInterval() {
+    if (this.#timeoutInterval !== void 0) {
+      return;
+    }
+    this.#timeoutInterval = setInterval(() => {
+      this.#checkTimeout();
+    }, this.#timeoutCheckIntervalMs);
+  }
+  #maybeStopTimeoutInterval() {
+    if (this.#timeoutInterval === void 0) {
+      return;
+    }
+    clearInterval(this.#timeoutInterval);
+    this.#timeoutInterval = void 0;
+  }
+};
 
 // ../zql/src/ivm/memory-storage.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
@@ -11866,21 +12089,6 @@ var MemorySource = class _MemorySource {
     const exists = (row) => data.has(row);
     const setOverlay = (o) => this.#overlay = o;
     const writeChange = (c) => this.#writeChange(c);
-    if (change.type === "set") {
-      const existing = data.get(change.row);
-      if (existing !== void 0) {
-        change = {
-          type: "edit",
-          row: change.row,
-          oldRow: existing
-        };
-      } else {
-        change = {
-          type: "add",
-          row: change.row
-        };
-      }
-    }
     yield* genPushAndWriteWithSplitEdit(
       this.#connections,
       change,
@@ -12579,16 +12787,10 @@ async function upsertImpl(tx, arg, schema, ivmBranch) {
     schema.tables[arg.tableName].primaryKey,
     arg.value
   );
-  const val = defaultOptionalFieldsToNull(
-    schema.tables[arg.tableName],
-    arg.value
-  );
-  await tx.set(key, val);
-  if (ivmBranch) {
-    must(ivmBranch.getSource(arg.tableName)).push({
-      type: "set",
-      row: arg.value
-    });
+  if (await tx.has(key)) {
+    await updateImpl(tx, { ...arg, op: "update" }, schema, ivmBranch);
+  } else {
+    await insertImpl(tx, { ...arg, op: "insert" }, schema, ivmBranch);
   }
 }
 async function updateImpl(tx, arg, schema, ivmBranch) {
@@ -13065,7 +13267,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.24.2025102100";
+var version2 = "0.25.0-canary.0";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -13121,7 +13323,84 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
   };
 }
 
+// ../zero-client/src/client/client-error-kind-enum.ts
+var client_error_kind_enum_exports = {};
+__export(client_error_kind_enum_exports, {
+  AbruptClose: () => AbruptClose,
+  CleanClose: () => CleanClose,
+  ClientClosed: () => ClientClosed,
+  ConnectTimeout: () => ConnectTimeout,
+  DisconnectTimeout: () => DisconnectTimeout,
+  Hidden: () => Hidden,
+  NoSocketOrigin: () => NoSocketOrigin,
+  PingTimeout: () => PingTimeout,
+  UnexpectedBaseCookie: () => UnexpectedBaseCookie
+});
+var AbruptClose = "AbruptClose";
+var CleanClose = "CleanClose";
+var ClientClosed = "ClientClosed";
+var ConnectTimeout = "ConnectTimeout";
+var DisconnectTimeout = "DisconnectTimeout";
+var UnexpectedBaseCookie = "UnexpectedBaseCookie";
+var PingTimeout = "PingTimeout";
+var Hidden = "Hidden";
+var NoSocketOrigin = "NoSocketOrigin";
+
+// ../zero-client/src/client/error.ts
+var BaseError = class extends Error {
+  errorBody;
+  constructor(errorBody, options) {
+    super(errorBody.kind + ": " + errorBody.message, options);
+    this.errorBody = errorBody;
+  }
+  get kind() {
+    return this.errorBody.kind;
+  }
+};
+var ServerError = class extends BaseError {
+  get name() {
+    return "ServerError";
+  }
+};
+var ClientError = class extends BaseError {
+  get name() {
+    return "ClientError";
+  }
+};
+function isServerError(ex) {
+  return ex instanceof ServerError;
+}
+function isAuthError(ex) {
+  return isServerError(ex) && isAuthErrorKind(ex.kind);
+}
+function isAuthErrorKind(kind) {
+  return kind === error_kind_enum_exports.AuthInvalidated || kind === error_kind_enum_exports.Unauthorized;
+}
+function isBackoffError(ex) {
+  if (isServerError(ex)) {
+    switch (ex.errorBody.kind) {
+      case error_kind_enum_exports.Rebalance:
+      case error_kind_enum_exports.Rehome:
+      case error_kind_enum_exports.ServerOverloaded:
+        return ex.errorBody;
+    }
+  }
+  return void 0;
+}
+function isClientError(ex) {
+  return ex instanceof ClientError;
+}
+
 // ../zero-client/src/client/metric-name-enum.ts
+var metric_name_enum_exports = {};
+__export(metric_name_enum_exports, {
+  LastConnectError: () => LastConnectError,
+  LastConnectErrorV2: () => LastConnectErrorV2,
+  NotConnected: () => NotConnected,
+  TimeToConnectMs: () => TimeToConnectMs,
+  TimeToConnectMsV2: () => TimeToConnectMsV2,
+  TotalTimeToConnectMs: () => TotalTimeToConnectMs
+});
 var TimeToConnectMs = "time_to_connect_ms";
 var LastConnectError = "last_connect_error";
 var TimeToConnectMsV2 = "time_to_connect_ms_v2";
@@ -13133,13 +13412,10 @@ var NotConnected = "not_connected";
 var DID_NOT_CONNECT_VALUE = 100 * 1e3;
 var REPORT_INTERVAL_MS = 5e3;
 function getLastConnectErrorValue(reason) {
-  if ("server" in reason) {
-    return `server_${camelToSnake(reason.server)}`;
-  }
-  return `client_${camelToSnake(reason.client)}`;
+  return `${isServerError(reason) ? "server_" : "client_"}${camelToSnake(reason.kind)}`;
 }
-function camelToSnake(s) {
-  return s.split(/\.?(?=[A-Z])/).join("_").toLowerCase();
+function camelToSnake(kind) {
+  return kind.split(/\.?(?=[A-Z])/).join("_").toLowerCase();
 }
 var MetricManager = class {
   #reportIntervalMs;
@@ -13180,7 +13456,7 @@ var MetricManager = class {
   // be encapsulated with the ConnectionState. This will probably happen as part
   // of https://github.com/rocicorp/reflect-server/issues/255.
   timeToConnectMs = this.#register(
-    new Gauge(TimeToConnectMs)
+    new Gauge(metric_name_enum_exports.TimeToConnectMs)
   );
   // lastConnectError records the last error that occurred when connecting,
   // if any. It is cleared when connecting successfully or when reported, so this
@@ -13188,28 +13464,28 @@ var MetricManager = class {
   // we are still not connected.
   lastConnectError = this.#register(
     new State(
-      LastConnectError,
+      metric_name_enum_exports.LastConnectError,
       true
       // clearOnFlush
     )
   );
   // notConnected records the reason why the client is not currently connected.
   // It is cleared when the client successfully connects.
-  #notConnected = this.#register(new State(NotConnected));
+  #notConnected = this.#register(new State(metric_name_enum_exports.NotConnected));
   // The time from the call to connect() to receiving the 'connected' ws message
   // for the current connection.  Cleared when the client is not connected.
   // TODO: Not actually currently cleared on disconnect untill there is a
   // connect error, or client reports disconnected and waiting for visible.
   // Should have a value iff _notConnected has no value.
   #timeToConnectMsV2 = this.#register(
-    new Gauge(TimeToConnectMsV2)
+    new Gauge(metric_name_enum_exports.TimeToConnectMsV2)
   );
   // lastConnectErrorV2 records the last error that occurred when connecting,
   // if any. It is cleared when the client successfully connects or
   // stops trying to connect due to being hidden.
   // Should have a value iff notConnected state is NotConnectedReason.Error.
   #lastConnectErrorV2 = this.#register(
-    new State(LastConnectErrorV2)
+    new State(metric_name_enum_exports.LastConnectErrorV2)
   );
   // The total time it took to connect across retries for the current
   // connection.  Cleared when the client is not connected.
@@ -13218,7 +13494,7 @@ var MetricManager = class {
   // See Zero.#totalToConnectStart for details of how this total is computed.
   // Should have a value iff _notConnected has no value.
   #totalTimeToConnectMs = this.#register(
-    new Gauge(TotalTimeToConnectMs)
+    new Gauge(metric_name_enum_exports.TotalTimeToConnectMs)
   );
   #setNotConnectedReason(reason) {
     this.#notConnected.set(reason);
@@ -13360,7 +13636,7 @@ var State = class {
 };
 
 // ../zero-client/src/client/mutation-tracker.ts
-import { resolver as resolver9 } from "@rocicorp/resolver";
+import { resolver as resolver10 } from "@rocicorp/resolver";
 var currentEphemeralID = 0;
 function nextEphemeralID() {
   return ++currentEphemeralID;
@@ -13398,7 +13674,7 @@ var MutationTracker = class {
   }
   trackMutation() {
     const id = nextEphemeralID();
-    const mutationResolver = resolver9();
+    const mutationResolver = resolver10();
     this.#outstandingMutations.set(id, {
       resolver: mutationResolver
     });
@@ -14052,39 +14328,6 @@ function nextBackoff(lc, now) {
   };
 }
 
-// ../zero-client/src/client/server-error.ts
-var ServerError = class extends Error {
-  name = "ServerError";
-  errorBody;
-  get kind() {
-    return this.errorBody.kind;
-  }
-  constructor(errorBody) {
-    super(errorBody.kind + ": " + errorBody.message);
-    this.errorBody = errorBody;
-  }
-};
-function isServerError(ex) {
-  return ex instanceof ServerError;
-}
-function isAuthError(ex) {
-  return isServerError(ex) && isAuthErrorKind(ex.kind);
-}
-function isAuthErrorKind(kind) {
-  return kind === error_kind_enum_exports.AuthInvalidated || kind === error_kind_enum_exports.Unauthorized;
-}
-function isBackoffError(ex) {
-  if (isServerError(ex)) {
-    switch (ex.errorBody.kind) {
-      case error_kind_enum_exports.Rebalance:
-      case error_kind_enum_exports.Rehome:
-      case error_kind_enum_exports.ServerOverloaded:
-        return ex.errorBody;
-    }
-  }
-  return void 0;
-}
-
 // ../zero-client/src/client/server-option.ts
 function validateServerParam(paramName, server) {
   const expectedProtocol = "http";
@@ -14508,7 +14751,6 @@ var ZeroRep = class {
 };
 
 // ../zero-client/src/client/zero.ts
-var onSetConnectionStateSymbol = Symbol();
 var exposedToTestingSymbol = Symbol();
 var createLogOptionsSymbol = Symbol();
 var RUN_LOOP_INTERVAL_MS = 5e3;
@@ -14516,6 +14758,7 @@ var PING_INTERVAL_MS = 5e3;
 var PING_TIMEOUT_MS = 5e3;
 var PULL_TIMEOUT_MS = 5e3;
 var DEFAULT_DISCONNECT_HIDDEN_DELAY_MS = 5e3;
+var DEFAULT_DISCONNECT_TIMEOUT_MS = 5 * 60 * 1e3;
 var CONNECT_TIMEOUT_MS = 1e4;
 var CHECK_CONNECTIVITY_ON_ERROR_FREQUENCY = 6;
 var NULL_LAST_MUTATION_ID_SENT = { clientID: "", id: -1 };
@@ -14602,12 +14845,11 @@ var Zero = class _Zero {
   };
   #zeroContext;
   queryDelegate;
-  #connectResolver = resolver10();
+  #connectResolver = resolver11();
   #pendingPullsByRequestID = /* @__PURE__ */ new Map();
   #lastMutationIDReceived = 0;
   #socket = void 0;
-  #socketResolver = resolver10();
-  #connectionStateChangeResolver = resolver10();
+  #socketResolver = resolver11();
   /**
    * This resolver is only used for rejections. It is awaited in the connected
    * state (including when waiting for a pong). It is rejected when we get an
@@ -14616,21 +14858,9 @@ var Zero = class _Zero {
   #rejectMessageError = void 0;
   #closeAbortController = new AbortController();
   #visibilityWatcher;
-  // We use an accessor pair to allow the subclass to override the setter.
-  #connectionState = Disconnected;
+  #connectionManager;
   #activeClientsManager;
   #inspector;
-  #setConnectionState(state) {
-    if (state === this.#connectionState) {
-      return;
-    }
-    this.#connectionState = state;
-    this.#connectionStateChangeResolver.resolve(state);
-    this.#connectionStateChangeResolver = resolver10();
-    if (false) {
-      asTestZero(this)[onSetConnectionStateSymbol]?.(state);
-    }
-  }
   #connectStart = void 0;
   // Set on connect attempt if currently undefined.
   // Reset to undefined when
@@ -14698,6 +14928,9 @@ var Zero = class _Zero {
       enableAnalytics: this.#enableAnalytics
     });
     const logOptions = this.#logOptions;
+    this.#connectionManager = new ConnectionManager({
+      disconnectTimeoutMs: DEFAULT_DISCONNECT_TIMEOUT_MS
+    });
     const { enableLegacyMutators = true, enableLegacyQueries = true } = schema;
     const replicacheMutators = {
       [CRUD_MUTATION_NAME]: enableLegacyMutators ? makeCRUDMutator(schema) : () => Promise.reject(new Error("Zero CRUD mutators are not enabled."))
@@ -14946,7 +15179,7 @@ var Zero = class _Zero {
         logOptions: this.#logOptions,
         connectStart: () => this.#connectStart,
         socketResolver: () => this.#socketResolver,
-        connectionState: () => this.#connectionState
+        connectionManager: () => this.#connectionManager
       };
     }
   }
@@ -14978,7 +15211,7 @@ var Zero = class _Zero {
     }
   }
   #send(msg) {
-    if (this.#socket && this.#connectionState === Connected) {
+    if (this.#socket && this.#connectionManager.is(connection_status_enum_exports.Connected)) {
       send(this.#socket, msg);
     }
   }
@@ -15025,6 +15258,27 @@ var Zero = class _Zero {
   get schemaVersion() {
     return this.#rep.schemaVersion;
   }
+  /**
+   * The schema passed into Zero when it was constructed.
+   *
+   * This can be paired with the inspector API to explore the client cache for
+   * debugging or tooling. The inspector exposes the raw key/value map as well
+   * as the per-table rows that back `zero.query[tableName].run()`.
+   *
+   * ```ts
+   * const inspector = __zero.inspector;
+   * const client = inspector.client;
+   *
+   * console.log('client map:', await client.map());
+   *
+   * for (const tableName of Object.keys(__zero.schema.tables)) {
+   *   console.table(await client.rows(tableName));
+   * }
+   * ```
+   */
+  get schema() {
+    return this.#options.schema;
+  }
   /**
    * The client ID for this instance of Zero. Each instance
    * gets a unique client ID.
@@ -15079,7 +15333,7 @@ var Zero = class _Zero {
    * longer query or mutate data with it, and its query views stop updating.
    */
   get closed() {
-    return this.#rep.closed;
+    return this.#connectionManager.is(connection_status_enum_exports.Closed);
   }
   /**
    * Closes this Zero instance.
@@ -15089,23 +15343,36 @@ var Zero = class _Zero {
    */
   async close() {
     const lc = this.#lc.withContext("close");
-    lc.debug?.("Closing Zero instance. Stack:", new Error().stack);
-    this.#onlineManager.cleanup();
-    if (this.#connectionState !== Disconnected) {
-      this.#disconnect(
-        lc,
-        {
-          client: "ClientClosed"
-        },
-        CLOSE_CODE_NORMAL
-      );
+    try {
+      if (this.closed) {
+        lc.debug?.("close() called on already closed instance");
+        return;
+      }
+      lc.debug?.("Closing Zero instance. Stack:", new Error().stack);
+      this.#onlineManager.cleanup();
+      if (!this.#connectionManager.is(connection_status_enum_exports.Disconnected)) {
+        this.#disconnect(
+          lc,
+          new ClientError({
+            kind: client_error_kind_enum_exports.ClientClosed,
+            message: "Zero instance closed by user"
+          }),
+          CLOSE_CODE_NORMAL
+        );
+      }
+      lc.debug?.("Aborting closeAbortController due to close()");
+      this.#closeAbortController.abort();
+      this.#metrics.stop();
+      const ret = await this.#rep.close();
+      this.#unexpose();
+      return ret;
+    } catch (e) {
+      lc.error?.("Error closing Zero instance", e);
+      throw e;
+    } finally {
+      this.#connectionManager.closed();
+      this.#connectionManager.cleanup();
     }
-    lc.debug?.("Aborting closeAbortController due to close()");
-    this.#closeAbortController.abort();
-    this.#metrics.stop();
-    const ret = await this.#rep.close();
-    this.#unexpose();
-    return ret;
   }
   #onMessage = (e) => {
     const lc = this.#lc;
@@ -15193,9 +15460,17 @@ var Zero = class _Zero {
         wasClean
       });
     }
-    const closeKind = wasClean ? "CleanClose" : "AbruptClose";
-    this.#connectResolver.reject(new CloseError(closeKind));
-    this.#disconnect(lc, { client: closeKind });
+    const closeError2 = new ClientError(
+      wasClean ? {
+        kind: client_error_kind_enum_exports.CleanClose,
+        message: "WebSocket connection closed cleanly"
+      } : {
+        kind: client_error_kind_enum_exports.AbruptClose,
+        message: "WebSocket connection closed abruptly"
+      }
+    );
+    this.#connectResolver.reject(closeError2);
+    this.#disconnect(lc, closeError2);
   };
   // An error on the connection is fatal for the connection.
   async #handleErrorMessage(lc, downMessage) {
@@ -15213,7 +15488,7 @@ ${error.errorBody.message}`, error);
     this.#rejectMessageError?.reject(error);
     lc.debug?.("Rejecting connect resolver due to error", error);
     this.#connectResolver.reject(error);
-    this.#disconnect(lc, { server: kind });
+    this.#disconnect(lc, error);
     if (kind === error_kind_enum_exports.VersionNotSupported) {
       this.#onUpdateNeeded({ type: kind, message });
     } else if (kind === error_kind_enum_exports.SchemaVersionNotSupported) {
@@ -15311,7 +15586,7 @@ ${error.errorBody.message}`, error);
     }
     this.#initConnectionQueries = void 0;
     maybeSendDeletedClients();
-    this.#setConnectionState(Connected);
+    this.#connectionManager.connected();
     this.#connectResolver.resolve();
   }
   /**
@@ -15319,8 +15594,9 @@ ${error.errorBody.message}`, error);
    * request to the server.
    *
    * {@link #connect} will throw an assertion error if the
-   * {@link #connectionState} is not {@link ConnectionState.Disconnected}.
-   * Callers MUST check the connection state before calling this method and log
+   * {@link #connectionManager} status is not {@link ConnectionState.Disconnected}
+   * or {@link ConnectionState.Connecting}.
+   * Callers MUST check the connection status before calling this method and log
    * an error as needed.
    *
    * The function will resolve once the socket is connected. If you need to know
@@ -15332,11 +15608,13 @@ ${error.errorBody.message}`, error);
    */
   async #connect(lc, additionalConnectParams) {
     assert(this.#server);
-    assert(this.#connectionState === Disconnected);
+    assert(
+      this.#connectionManager.is(connection_status_enum_exports.Disconnected) || this.#connectionManager.is(connection_status_enum_exports.Connecting)
+    );
     const wsid = nanoid();
     lc = addWebSocketIDToLogContext(wsid, lc);
     lc.info?.("Connecting...", { navigatorOnline: localNavigator?.onLine });
-    this.#setConnectionState(Connecting);
+    this.#connectionManager.connecting();
     assert(this.#connectStart === void 0);
     const now = Date.now();
     this.#connectStart = now;
@@ -15356,10 +15634,12 @@ ${error.errorBody.message}`, error);
     }
     const timeoutID = setTimeout(() => {
       lc.debug?.("Rejecting connect resolver due to timeout");
-      this.#connectResolver.reject(new TimedOutError("Connect"));
-      this.#disconnect(lc, {
-        client: "ConnectTimeout"
+      const timeoutError = new ClientError({
+        kind: client_error_kind_enum_exports.ConnectTimeout,
+        message: `Connection attempt timed out after ${CONNECT_TIMEOUT_MS / 1e3} seconds`
       });
+      this.#connectResolver.reject(timeoutError);
+      this.#disconnect(lc, timeoutError);
     }, CONNECT_TIMEOUT_MS);
     const abortHandler = () => {
       clearTimeout(timeoutID);
@@ -15411,22 +15691,23 @@ ${error.errorBody.message}`, error);
     }
   }
   #disconnect(lc, reason, closeCode) {
-    if (this.#connectionState === Connecting) {
+    if (this.#connectionManager.is(connection_status_enum_exports.Connecting)) {
       this.#connectErrorCount++;
     }
     lc.info?.("disconnecting", {
       navigatorOnline: localNavigator?.onLine,
-      reason,
+      reason: reason.kind,
       connectStart: this.#connectStart,
       totalToConnectStart: this.#totalToConnectStart,
       connectedAt: this.#connectedAt,
       connectionDuration: this.#connectedAt ? Date.now() - this.#connectedAt : 0,
       messageCount: this.#messageCount,
-      connectionState: this.#connectionState,
+      connectionState: this.#connectionManager.state,
       connectErrorCount: this.#connectErrorCount
     });
-    switch (this.#connectionState) {
-      case Connected: {
+    const connectionState = this.#connectionManager.state.name;
+    switch (connectionState) {
+      case connection_status_enum_exports.Connected: {
         if (this.#connectStart !== void 0) {
           lc.error?.(
             "disconnect() called while connected but connect start time is defined."
@@ -15434,7 +15715,8 @@ ${error.errorBody.message}`, error);
         }
         break;
       }
-      case Connecting: {
+      case connection_status_enum_exports.Disconnected:
+      case connection_status_enum_exports.Connecting: {
         this.#metrics.lastConnectError.set(getLastConnectErrorValue(reason));
         this.#metrics.timeToConnectMs.set(DID_NOT_CONNECT_VALUE);
         this.#metrics.setConnectError(reason);
@@ -15450,14 +15732,13 @@ ${error.errorBody.message}`, error);
         }
         break;
       }
-      case Disconnected:
-        lc.error?.("disconnect() called while disconnected");
-        break;
+      case connection_status_enum_exports.Closed:
+        lc.error?.("disconnect() called while closed");
+        return;
     }
-    this.#socketResolver = resolver10();
+    this.#socketResolver = resolver11();
     lc.debug?.("Creating new connect resolver");
-    this.#connectResolver = resolver10();
-    this.#setConnectionState(Disconnected);
+    this.#connectResolver = resolver11();
     this.#messageCount = 0;
     this.#connectStart = void 0;
     this.#connectedAt = 0;
@@ -15468,6 +15749,12 @@ ${error.errorBody.message}`, error);
     this.#socket = void 0;
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     this.#pokeHandler.handleDisconnect();
+    const isStillConnecting = reason instanceof ClientError && (reason.kind === client_error_kind_enum_exports.ConnectTimeout || reason.kind === client_error_kind_enum_exports.Hidden);
+    if (isStillConnecting) {
+      this.#connectionManager.connecting(reason);
+    } else {
+      this.#connectionManager.disconnected(reason);
+    }
   }
   #handlePokeStart(_lc, pokeMessage) {
     this.#abortPingTimeout();
@@ -15490,12 +15777,16 @@ ${error.errorBody.message}`, error);
     const lc = this.#lc;
     lc.info?.(
       "poke error, disconnecting?",
-      this.#connectionState !== Disconnected
+      !this.#connectionManager.is(connection_status_enum_exports.Disconnected)
     );
-    if (this.#connectionState !== Disconnected) {
-      this.#disconnect(lc, {
-        client: "UnexpectedBaseCookie"
-      });
+    if (!this.#connectionManager.is(connection_status_enum_exports.Disconnected)) {
+      this.#disconnect(
+        lc,
+        new ClientError({
+          kind: client_error_kind_enum_exports.UnexpectedBaseCookie,
+          message: "Server returned unexpected base cookie during sync"
+        })
+      );
     }
   }
   #handlePullResponse(lc, pullResponseMessage) {
@@ -15503,12 +15794,12 @@ ${error.errorBody.message}`, error);
     const body = pullResponseMessage[1];
     lc = lc.withContext("requestID", body.requestID);
     lc.debug?.("Handling pull response", body);
-    const resolver11 = this.#pendingPullsByRequestID.get(body.requestID);
-    if (!resolver11) {
+    const resolver12 = this.#pendingPullsByRequestID.get(body.requestID);
+    if (!resolver12) {
       lc.debug?.("No resolver found");
       return;
     }
-    resolver11.resolve(pullResponseMessage[1]);
+    resolver12.resolve(pullResponseMessage[1]);
   }
   async #pusher(req, requestID) {
     assert(req.pushVersion === 1);
@@ -15581,6 +15872,12 @@ ${error.errorBody.message}`, error);
     this.#lc.info?.(`Starting Zero version: ${this.version}`);
     if (this.#server === null) {
       this.#lc.info?.("No socket origin provided, not starting connect loop.");
+      this.#connectionManager.disconnected(
+        new ClientError({
+          kind: client_error_kind_enum_exports.NoSocketOrigin,
+          message: "No server socket origin provided"
+        })
+      );
       return;
     }
     let runLoopCounter = 0;
@@ -15598,13 +15895,14 @@ ${error.errorBody.message}`, error);
     let gotError = false;
     let backoffMs = RUN_LOOP_INTERVAL_MS;
     let additionalConnectParams;
-    while (!this.closed) {
+    while (this.#connectionManager.shouldContinueRunLoop()) {
       runLoopCounter++;
       let lc = getLogContext();
       backoffMs = RUN_LOOP_INTERVAL_MS;
       try {
-        switch (this.#connectionState) {
-          case Disconnected: {
+        switch (this.#connectionManager.state.name) {
+          case connection_status_enum_exports.Connecting:
+          case connection_status_enum_exports.Disconnected: {
             if (this.#visibilityWatcher.visibilityState === "hidden") {
               this.#metrics.setDisconnectedWaitingForVisible();
               this.#totalToConnectStart = void 0;
@@ -15630,25 +15928,21 @@ ${error.errorBody.message}`, error);
             this.#setOnline(true);
             break;
           }
-          case Connecting:
-            lc.error?.("unreachable");
-            gotError = true;
-            break;
-          case Connected: {
+          case connection_status_enum_exports.Connected: {
             const controller = new AbortController();
             this.#abortPingTimeout = () => controller.abort();
             const [pingTimeoutPromise, pingTimeoutAborted] = sleepWithAbort(
               PING_INTERVAL_MS,
               controller.signal
             );
-            this.#rejectMessageError = resolver10();
+            this.#rejectMessageError = resolver11();
             const PING = 0;
             const HIDDEN = 2;
             const raceResult = await promiseRace([
               pingTimeoutPromise,
               pingTimeoutAborted,
               this.#visibilityWatcher.waitForHidden(),
-              this.#connectionStateChangeResolver.promise,
+              this.#connectionManager.waitForStateChange(),
               this.#rejectMessageError.promise
             ]);
             if (this.closed) {
@@ -15667,17 +15961,25 @@ ${error.errorBody.message}`, error);
                 break;
               }
               case HIDDEN:
-                this.#disconnect(lc, {
-                  client: "Hidden"
-                });
+                this.#disconnect(
+                  lc,
+                  new ClientError({
+                    kind: client_error_kind_enum_exports.Hidden,
+                    message: "Connection closed because tab was hidden"
+                  })
+                );
                 this.#setOnline(false);
                 break;
             }
             this.#rejectMessageError = void 0;
+            break;
           }
+          case connection_status_enum_exports.Closed:
+            this.#rejectMessageError = void 0;
+            break;
         }
       } catch (ex) {
-        if (this.#connectionState !== Connected) {
+        if (!this.#connectionManager.is(connection_status_enum_exports.Connected)) {
           const level = isAuthError(ex) ? "warn" : "error";
           const kind = isServerError(ex) ? ex.kind : "Unknown Error";
           lc[level]?.("Failed to connect", ex, kind, {
@@ -15688,7 +15990,7 @@ ${error.errorBody.message}`, error);
         lc.debug?.(
           "Got an exception in the run loop",
           "state:",
-          this.#connectionState,
+          this.#connectionManager.state,
           "exception:",
           ex
         );
@@ -15700,7 +16002,7 @@ ${error.errorBody.message}`, error);
             continue;
           }
         }
-        if (isServerError(ex) || ex instanceof TimedOutError || ex instanceof CloseError) {
+        if (isServerError(ex) || isClientError(ex) && (ex.kind === client_error_kind_enum_exports.ConnectTimeout || ex.kind === client_error_kind_enum_exports.AbruptClose || ex.kind === client_error_kind_enum_exports.CleanClose)) {
           gotError = true;
         }
         const backoffError = isBackoffError(ex);
@@ -15720,7 +16022,7 @@ ${error.errorBody.message}`, error);
           "Sleeping",
           backoffMs,
           "ms before reconnecting due to error, state:",
-          this.#connectionState
+          this.#connectionManager.state
         );
         await sleep(backoffMs);
       }
@@ -15756,7 +16058,7 @@ ${error.errorBody.message}`, error);
       }
     ];
     send(socket, pullRequestMessage);
-    const pullResponseResolver = resolver10();
+    const pullResponseResolver = resolver11();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
       const TIMEOUT = 0;
@@ -15819,7 +16121,7 @@ ${error.errorBody.message}`, error);
    */
   async #ping(lc, messageErrorRejectionPromise) {
     lc.debug?.("pinging");
-    const { promise, resolve } = resolver10();
+    const { promise, resolve } = resolver11();
     this.#onPong = resolve;
     const pingMessage = ["ping", {}];
     const t0 = performance.now();
@@ -15833,9 +16135,13 @@ ${error.errorBody.message}`, error);
     const delta = performance.now() - t0;
     if (!connected) {
       lc.info?.("ping failed in", delta, "ms - disconnecting");
-      this.#disconnect(lc, {
-        client: "PingTimeout"
-      });
+      this.#disconnect(
+        lc,
+        new ClientError({
+          kind: client_error_kind_enum_exports.PingTimeout,
+          message: "Server ping request timed out"
+        })
+      );
       return TimedOut;
     }
     lc.debug?.("ping succeeded in", delta, "ms");
@@ -16001,13 +16307,6 @@ function addWebSocketIDToLogContext(wsid, lc) {
 function promiseRace(ps) {
   return Promise.race(ps.map((p, i) => p.then(() => i)));
 }
-var TimedOutError = class extends Error {
-  constructor(m) {
-    super(`${m} timed out`);
-  }
-};
-var CloseError = class extends Error {
-};
 function assertValidRunOptions2(_options) {
 }
 async function makeActiveClientsManager(clientGroupID, clientID, signal, onDelete) {
@@ -16048,4 +16347,4 @@ export {
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-TA2NZPJQ.js.map
+//# sourceMappingURL=chunk-MXPHMVU7.js.map