@rocicorp/zero 0.7.2024120200 → 0.7.2024120700

package/out/{chunk-KL66XOAW.js → chunk-PFF4AHTF.js}

@@ -14,7 +14,7 @@ import {
   must,
   throwInvalidType,
   unreachable
-} from "./chunk-C7M3BJ3Z.js";
+} from "./chunk-6HXO6VMP.js";
 import {
   __export,
   __reExport
@@ -9291,8 +9291,8 @@ function isJunctionRelationship(relationship) {
 }
 
 // ../shared/src/sorted-entries.ts
-function sortedEntries(object17) {
-  return Object.entries(object17).sort((a, b) => stringCompare(a[0], b[0]));
+function sortedEntries(object18) {
+  return Object.entries(object18).sort((a, b) => stringCompare(a[0], b[0]));
 }
 
 // ../zero-schema/src/normalize-table-schema.ts
@@ -9344,28 +9344,36 @@ function assertNoDuplicates(arr) {
     "Primary key must not contain duplicates"
   );
 }
-function normalizePrimaryKey(arr) {
-  assertNoDuplicates(arr);
-  return arr;
+function normalizePrimaryKey(primaryKey) {
+  if (typeof primaryKey === "string") {
+    return [primaryKey];
+  }
+  assertNoDuplicates(primaryKey);
+  return primaryKey;
 }
 function normalizeColumns(columns, primaryKey) {
   const rv = {};
   for (const pk of primaryKey) {
     const schemaValue = columns[pk];
     assert(schemaValue, `Primary key column "${pk}" not found`);
-    const { type, optional } = schemaValue;
-    assert(!optional, `Primary key column "${pk}" cannot be optional`);
-    assert(
-      type === "string" || type === "number" || type === "boolean",
-      `Primary key column "${pk}" must be a string, number, or boolean. Got ${type}`
-    );
+    if (typeof schemaValue !== "string") {
+      const { type, optional } = schemaValue;
+      assert(!optional, `Primary key column "${pk}" cannot be optional`);
+      assert(
+        type === "string" || type === "number" || type === "boolean",
+        `Primary key column "${pk}" must be a string, number, or boolean. Got ${type}`
+      );
+    }
   }
   for (const [name, column] of sortedEntries(columns)) {
-    rv[name] = normalizeSchemaValue(column);
+    rv[name] = normalizeColumn(column);
   }
   return rv;
 }
-function normalizeSchemaValue(value) {
+function normalizeColumn(value) {
+  if (typeof value === "string") {
+    return { type: value, optional: false };
+  }
   return {
     type: value.type,
     optional: value.optional ?? false
@@ -9373,8 +9381,10 @@ function normalizeSchemaValue(value) {
 }
 function normalizeRelationships(relationships, tableSchemaCache) {
   const rv = {};
-  for (const [name, relationship] of sortedEntries(relationships)) {
-    rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+  if (relationships) {
+    for (const [name, relationship] of sortedEntries(relationships)) {
+      rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+    }
   }
   return rv;
 }
@@ -9385,13 +9395,15 @@ function normalizeRelationship(relationship, tableSchemaCache) {
   return normalizeJunctionRelationship(relationship, tableSchemaCache);
 }
 function normalizeFieldRelationship(relationship, tableSchemaCache) {
+  const sourceField = normalizeFieldName(relationship.sourceField);
+  const destField = normalizeFieldName(relationship.destField);
   assert(
-    relationship.sourceField.length === relationship.destField.length,
+    sourceField.length === destField.length,
     "Source and destination fields must have the same length"
   );
   return {
-    sourceField: relationship.sourceField,
-    destField: relationship.destField,
+    sourceField,
+    destField,
     destSchema: normalizeLazyTableSchema(
       relationship.destSchema,
       tableSchemaCache
@@ -9413,6 +9425,20 @@ function normalizeLazyTableSchema(tableSchema, buildCache) {
     buildCache
   );
 }
+function normalizeFieldName(sourceField) {
+  if (typeof sourceField === "string") {
+    return [sourceField];
+  }
+  assert(sourceField.length > 0, "Expected at least one field");
+  return sourceField;
+}
+function normalizeTables(tables) {
+  const result = {};
+  for (const [name, table] of sortedEntries(tables)) {
+    result[name] = normalizeTableSchemaWithCache(table, name, /* @__PURE__ */ new Map());
+  }
+  return result;
+}
 
 // ../zero-schema/src/normalized-schema.ts
 function normalizeSchema(schema) {
@@ -9426,10 +9452,10 @@ var NormalizedSchema = class {
   tables;
   constructor(schema) {
     this.version = schema.version;
-    this.tables = normalizeTables(schema.tables);
+    this.tables = normalizeTables2(schema.tables);
   }
 };
-function normalizeTables(tables) {
+function normalizeTables2(tables) {
   const rv = {};
   const tableSchemaCache = /* @__PURE__ */ new Map();
   for (const [name, table] of sortedEntries(tables)) {
@@ -9657,7 +9683,7 @@ var simpleOperatorSchema = valita_exports.union(
   likeOpsSchema,
   inOpsSchema
 );
-var literalReferenceSchema = valita_exports.object({
+var literalReferenceSchema = readonlyObject({
   type: valita_exports.literal("literal"),
   value: valita_exports.union(
     valita_exports.string(),
@@ -9667,11 +9693,11 @@ var literalReferenceSchema = valita_exports.object({
     readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean()))
   )
 });
-var columnReferenceSchema = valita_exports.object({
+var columnReferenceSchema = readonlyObject({
   type: valita_exports.literal("column"),
   name: valita_exports.string()
 });
-var parameterReferenceSchema = valita_exports.object({
+var parameterReferenceSchema = readonlyObject({
   type: valita_exports.literal("static"),
   anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
   field: valita_exports.string()
@@ -9681,16 +9707,13 @@ var conditionValueSchema = valita_exports.union(
   columnReferenceSchema,
   parameterReferenceSchema
 );
-var simpleConditionSchema = valita_exports.object({
+var simpleConditionSchema = readonlyObject({
   type: valita_exports.literal("simple"),
   op: simpleOperatorSchema,
   left: conditionValueSchema,
   right: valita_exports.union(parameterReferenceSchema, literalReferenceSchema)
 });
-var correlatedSubqueryConditionOperatorSchema = valita_exports.union(
-  valita_exports.literal("EXISTS"),
-  valita_exports.literal("NOT EXISTS")
-);
+var correlatedSubqueryConditionOperatorSchema = valita_exports.union(valita_exports.literal("EXISTS"), valita_exports.literal("NOT EXISTS"));
 var correlatedSubqueryConditionSchema = readonlyObject({
   type: valita_exports.literal("correlatedSubquery"),
   related: valita_exports.lazy(() => correlatedSubquerySchema),
@@ -9710,19 +9733,22 @@ var disjunctionSchema = readonlyObject({
   type: valita_exports.literal("or"),
   conditions: readonlyArray(conditionSchema)
 });
-var compoundKeySchema = valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()));
+var compoundKeySchema = readonly(
+  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
+);
 var correlationSchema = readonlyObject({
   parentField: compoundKeySchema,
   childField: compoundKeySchema
 });
 var correlatedSubquerySchemaOmitSubquery = readonlyObject({
   correlation: correlationSchema,
-  hidden: valita_exports.boolean().optional()
+  hidden: valita_exports.boolean().optional(),
+  system: valita_exports.union(valita_exports.literal("permissions"), valita_exports.literal("client")).optional()
 });
 var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
   subquery: valita_exports.lazy(() => astSchema)
 });
-var astSchema = valita_exports.object({
+var astSchema = readonlyObject({
   schema: valita_exports.string().optional(),
   table: valita_exports.string(),
   alias: valita_exports.string().optional(),
@@ -9752,7 +9778,8 @@ function normalizeAST(ast) {
         (r) => ({
           correlation: r.correlation,
           hidden: r.hidden,
-          subquery: normalizeAST(r.subquery)
+          subquery: normalizeAST(r.subquery),
+          system: r.system
         })
       )
     ) : void 0,
@@ -9813,7 +9840,7 @@ function compareValuePosition(a, b) {
   switch (a.type) {
     case "literal":
       assert(b.type === "literal");
-      return compareUTF8MaybeNull(String(a.value), String(b.value));
+      return compareUTF83(String(a.value), String(b.value));
     case "column":
       assert(b.type === "column");
       return compareUTF83(a.name, b.name);
@@ -9913,13 +9940,14 @@ function compareValues(a, b) {
 function normalizeUndefined(v2) {
   return v2 ?? null;
 }
-function makeComparator(order) {
+function makeComparator(order, reverse) {
   return (a, b) => {
     for (const ord of order) {
       const field = ord[0];
       const comp = compareValues(a[field], b[field]);
       if (comp !== 0) {
-        return ord[1] === "asc" ? comp : -comp;
+        const result = ord[1] === "asc" ? comp : -comp;
+        return reverse ? -result : result;
       }
     }
     return 0;
@@ -10002,7 +10030,11 @@ var Exists = class {
         return;
       }
       case "remove": {
-        this.#pushWithFilter(change);
+        const size = this.#getSize(change.node.row);
+        if (size === void 0) {
+          return;
+        }
+        this.#pushWithFilter(change, size);
         this.#delSize(change.node.row);
         return;
       }
@@ -10111,13 +10143,20 @@ var Exists = class {
     return size;
   }
   #fetchNodeForRow(row) {
-    return must(
+    const fetched = must(
       first(
         this.#input.fetch({
           start: { row, basis: "at" }
         })
       )
     );
+    assert(
+      this.getSchema().compareRows(row, fetched.row) === 0,
+      () => `fetchNodeForRow returned unexpected row, expected ${JSON.stringify(
+        row
+      )}, received ${JSON.stringify(fetched.row)}`
+    );
+    return fetched;
   }
   #makeSizeStorageKey(row) {
     const primaryKey = [];
@@ -10317,7 +10356,8 @@ var Join = class {
     parentKey,
     childKey,
     relationshipName,
-    hidden
+    hidden,
+    system
   }) {
     assert(parent !== child, "Parent and child must be different operators");
     assert(
@@ -10337,7 +10377,10 @@ var Join = class {
       isHidden: hidden,
       relationships: {
         ...parentSchema.relationships,
-        [relationshipName]: childSchema
+        [relationshipName]: {
+          ...childSchema,
+          system
+        }
       }
     };
     parent.setOutput({
@@ -10563,10 +10606,27 @@ var Skip = class {
     return this.#input.getSchema();
   }
   fetch(req) {
-    return this.#input.fetch({ ...req, start: this.#getStart(req) });
+    return this.#fetchOrCleanup("fetch", req);
   }
   cleanup(req) {
-    return this.#input.cleanup({ ...req, start: this.#getStart(req) });
+    return this.#fetchOrCleanup("fetch", req);
+  }
+  *#fetchOrCleanup(method, req) {
+    const start = this.#getStart(req);
+    if (start === "empty") {
+      return;
+    }
+    const nodes = this.#input[method]({ ...req, start });
+    if (!req.reverse) {
+      yield* nodes;
+      return;
+    }
+    for (const node of nodes) {
+      if (!this.#shouldBePresent(node.row)) {
+        return;
+      }
+      yield node;
+    }
   }
   setOutput(output) {
     this.#output = output;
@@ -10574,12 +10634,13 @@ var Skip = class {
   destroy() {
     this.#input.destroy();
   }
+  #shouldBePresent(row) {
+    const cmp2 = this.#comparator(this.#bound.row, row);
+    return cmp2 < 0 || cmp2 === 0 && !this.#bound.exclusive;
+  }
   push(change) {
     assert(this.#output, "Output not set");
-    const shouldBePresent = (row) => {
-      const cmp2 = this.#comparator(this.#bound.row, row);
-      return cmp2 < 0 || cmp2 === 0 && !this.#bound.exclusive;
-    };
+    const shouldBePresent = (row) => this.#shouldBePresent(row);
     if (change.type === "edit") {
       maybeSplitAndPushEditChange(change, shouldBePresent, this.#output);
       return;
@@ -10596,40 +10657,38 @@ var Skip = class {
       basis: this.#bound.exclusive ? "after" : "at"
     };
     if (!req.start) {
+      if (req.reverse) {
+        return void 0;
+      }
       return boundStart;
     }
     const cmp2 = this.#comparator(this.#bound.row, req.start.row);
-    if (cmp2 > 0) {
-      return boundStart;
-    }
-    if (cmp2 === 0) {
-      if (this.#bound.exclusive || req.start.basis === "after") {
-        return {
-          row: this.#bound.row,
-          basis: "after"
-        };
+    if (!req.reverse) {
+      if (cmp2 > 0) {
+        return boundStart;
+      }
+      if (cmp2 === 0) {
+        if (this.#bound.exclusive || req.start.basis === "after") {
+          return {
+            row: this.#bound.row,
+            basis: "after"
+          };
+        }
+        return boundStart;
       }
-      return boundStart;
-    }
-    assert(cmp2 < 0);
-    if (req.start.basis === "at" || req.start.basis === "after") {
       return req.start;
     }
-    req.start.basis;
-    const [node] = this.#input.fetch(req);
-    if (!node) {
-      return {
-        row: req.start.row,
-        basis: "at"
-      };
+    req.reverse;
+    if (cmp2 > 0) {
+      return "empty";
     }
-    if (this.#comparator(node.row, this.#bound.row) <= 0) {
-      return boundStart;
+    if (cmp2 === 0) {
+      if (!this.#bound.exclusive && req.start.basis === "at") {
+        return boundStart;
+      }
+      return "empty";
     }
-    return {
-      row: node.row,
-      basis: "at"
-    };
+    return req.start;
   }
 };
 
@@ -10697,10 +10756,8 @@ var Take = class {
   }
   *#initialFetch(req) {
     assert(req.start === void 0);
-    assert(
-      !this.#partitionKey || req.constraint && // TODO: Compound keys
-      constraintMatchesPartitionKey(req.constraint, this.#partitionKey)
-    );
+    assert(!req.reverse);
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
     if (this.#limit === 0) {
       return;
     }
@@ -10734,24 +10791,15 @@ var Take = class {
   }
   *cleanup(req) {
     assert(req.start === void 0);
-    assert(
-      !this.#partitionKey || req.constraint && // TODO: Compound keys
-      constraintMatchesPartitionKey(req.constraint, this.#partitionKey)
-    );
-    let takeState;
-    if (this.#limit > 0) {
-      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
-      takeState = this.#storage.get(takeStateKey);
-      assert(
-        takeState !== void 0,
-        "takeStateKey was: " + takeStateKey + ", partitionKey was: " + this.#partitionKey + ", constraint was: " + JSON.stringify(req.constraint)
-      );
-      this.#storage.del(takeStateKey);
-    }
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+    this.#storage.del(takeStateKey);
+    let size = 0;
     for (const inputNode of this.#input.cleanup(req)) {
-      if (takeState?.bound === void 0 || this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {
+      if (size === this.#limit) {
         return;
       }
+      size++;
       yield inputNode;
     }
   }
@@ -10808,13 +10856,14 @@ var Take = class {
           )
         );
       } else {
-        [beforeBoundNode, boundNode] = take(
+        [boundNode, beforeBoundNode] = take(
           this.#input.fetch({
             start: {
               row: takeState.bound,
-              basis: "before"
+              basis: "at"
             },
-            constraint
+            constraint,
+            reverse: true
           }),
           2
         );
@@ -10839,21 +10888,41 @@ var Take = class {
       if (compToBound > 0) {
         return;
       }
+      const [beforeBoundNode] = take(
+        this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "after"
+          },
+          constraint,
+          reverse: true
+        }),
+        1
+      );
       let newBound;
-      for (const node of this.#input.fetch({
-        start: {
-          row: takeState.bound,
-          basis: "before"
-        },
-        constraint
-      })) {
-        const push2 = compareRows(node.row, takeState.bound) > 0;
+      if (beforeBoundNode) {
+        const push2 = compareRows(beforeBoundNode.row, takeState.bound) > 0;
         newBound = {
-          node,
+          node: beforeBoundNode,
           push: push2
         };
-        if (push2) {
-          break;
+      }
+      if (!newBound?.push) {
+        for (const node of this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "at"
+          },
+          constraint
+        })) {
+          const push2 = compareRows(node.row, takeState.bound) > 0;
+          newBound = {
+            node,
+            push: push2
+          };
+          if (push2) {
+            break;
+          }
         }
       }
       if (newBound?.push) {
@@ -10928,9 +10997,10 @@ var Take = class {
             this.#input.fetch({
               start: {
                 row: takeState.bound,
-                basis: "before"
+                basis: "after"
               },
-              constraint
+              constraint,
+              reverse: true
             })
           )
         );
@@ -10981,13 +11051,14 @@ var Take = class {
         return;
       }
       assert(newCmp < 0);
-      const [newBoundNode, oldBoundNode] = take(
+      const [oldBoundNode, newBoundNode] = take(
         this.#input.fetch({
           start: {
             row: takeState.bound,
-            basis: "before"
+            basis: "at"
           },
-          constraint
+          constraint,
+          reverse: true
         }),
         2
       );
@@ -11070,6 +11141,12 @@ function getTakeStateKey(partitionKey, rowOrConstraint) {
   return JSON.stringify(["take", ...partitionValues]);
 }
 function constraintMatchesPartitionKey(constraint, partitionKey) {
+  if (constraint === void 0 || partitionKey === void 0) {
+    return constraint === partitionKey;
+  }
+  if (partitionKey.length !== Object.keys(constraint).length) {
+    return false;
+  }
   for (const key of partitionKey) {
     if (!hasOwn(constraint, key)) {
       return false;
@@ -11380,7 +11457,8 @@ function applyCorrelatedSubQuery(sq, delegate, end) {
     parentKey: sq.correlation.parentField,
     childKey: sq.correlation.childField,
     relationshipName: sq.subquery.alias,
-    hidden: sq.hidden ?? false
+    hidden: sq.hidden ?? false,
+    system: sq.system ?? "client"
   });
   return end;
 }
@@ -11501,12 +11579,21 @@ var ArrayView = class {
   #root;
   onDestroy;
   #dirty = false;
-  constructor(input, format = { singular: false, relationships: {} }) {
+  #complete = false;
+  constructor(input, format = { singular: false, relationships: {} }, queryComplete = true) {
     this.#input = input;
     this.#schema = input.getSchema();
     this.#format = format;
     this.#root = { "": format.singular ? void 0 : [] };
     input.setOutput(this);
+    if (queryComplete === true) {
+      this.#complete = true;
+    } else {
+      void queryComplete.then(() => {
+        this.#complete = true;
+        this.#fireListeners();
+      });
+    }
     this.#hydrate();
   }
   get data() {
@@ -11515,16 +11602,22 @@ var ArrayView = class {
   addListener(listener) {
     assert(!this.#listeners.has(listener), "Listener already registered");
     this.#listeners.add(listener);
-    listener(this.data);
+    this.#fireListener(listener);
     return () => {
       this.#listeners.delete(listener);
     };
   }
   #fireListeners() {
     for (const listener of this.#listeners) {
-      listener(this.data);
+      this.#fireListener(listener);
     }
   }
+  #fireListener(listener) {
+    listener(
+      this.data,
+      this.#complete ? "complete" : "unknown"
+    );
+  }
   destroy() {
     this.onDestroy?.();
   }
@@ -11686,6 +11779,7 @@ var AbstractQuery = class {
           related: [
             ...this.#ast.related ?? [],
             {
+              system: this._system,
               correlation: {
                 parentField: related.sourceField,
                 childField: related.destField
@@ -11725,6 +11819,7 @@ var AbstractQuery = class {
           related: [
             ...this.#ast.related ?? [],
             {
+              system: this._system,
               correlation: {
                 parentField: firstRelation.sourceField,
                 childField: firstRelation.destField
@@ -11735,6 +11830,7 @@ var AbstractQuery = class {
                 orderBy: addPrimaryKeys(junctionSchema, void 0),
                 related: [
                   {
+                    system: this._system,
                     correlation: {
                       parentField: secondRelation.sourceField,
                       childField: secondRelation.destField
@@ -11836,6 +11932,7 @@ var AbstractQuery = class {
       return {
         type: "correlatedSubquery",
         related: {
+          system: this._system,
           correlation: {
             parentField: related.sourceField,
             childField: related.destField
@@ -11863,6 +11960,7 @@ var AbstractQuery = class {
       return {
         type: "correlatedSubquery",
         related: {
+          system: this._system,
           correlation: {
             parentField: firstRelation.sourceField,
             childField: firstRelation.destField
@@ -11874,6 +11972,7 @@ var AbstractQuery = class {
             where: {
               type: "correlatedSubquery",
               related: {
+                system: this._system,
                 correlation: {
                   parentField: secondRelation.sourceField,
                   childField: secondRelation.destField
@@ -11927,6 +12026,7 @@ var QueryImpl = class extends AbstractQuery {
     this.#delegate = delegate;
     this.#ast = ast;
   }
+  _system = "client";
   // Not part of Query or QueryInternal interface
   get [astForTestingSymbol]() {
     return this.#ast;
@@ -11939,7 +12039,14 @@ var QueryImpl = class extends AbstractQuery {
   }
   materialize(factory) {
     const ast = this._completeAst();
-    const removeServerQuery = this.#delegate.addServerQuery(ast);
+    const queryCompleteResolver = resolver7();
+    let queryGot = false;
+    const removeServerQuery = this.#delegate.addServerQuery(ast, (got) => {
+      if (got) {
+        queryGot = true;
+        queryCompleteResolver.resolve(true);
+      }
+    });
     const input = buildPipeline(ast, this.#delegate);
     let removeCommitObserver;
     const onDestroy = () => {
@@ -11948,9 +12055,16 @@ var QueryImpl = class extends AbstractQuery {
       removeServerQuery();
     };
     const view = this.#delegate.batchViewUpdates(
-      () => (factory ?? arrayViewFactory)(this, input, this.format, onDestroy, (cb) => {
-        removeCommitObserver = this.#delegate.onTransactionCommit(cb);
-      })
+      () => (factory ?? arrayViewFactory)(
+        this,
+        input,
+        this.format,
+        onDestroy,
+        (cb) => {
+          removeCommitObserver = this.#delegate.onTransactionCommit(cb);
+        },
+        queryGot || queryCompleteResolver.promise
+      )
     );
     return view;
   }
@@ -11995,8 +12109,8 @@ function addPrimaryKeysToAst(schema, ast) {
     orderBy: addPrimaryKeys(schema, ast.orderBy)
   };
 }
-function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit) {
-  const v2 = new ArrayView(input, format);
+function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete) {
+  const v2 = new ArrayView(input, format, queryComplete);
   v2.onDestroy = onDestroy;
   onTransactionCommit(() => {
     v2.flush();
@@ -12012,6 +12126,7 @@ var AuthQuery = class _AuthQuery extends AbstractQuery {
   expressionBuilder() {
     return new ExpressionBuilder(this._exists);
   }
+  _system = "permissions";
   _newQuery(schema, ast, format) {
     return new _AuthQuery(schema, ast, format);
   }
@@ -12064,8 +12179,8 @@ function compileRowConfig(rowRules, expressionBuilder) {
         rowRules.update?.preMutation,
         expressionBuilder
       ),
-      postProposedMutation: compileRules(
-        rowRules.update?.postProposedMutation,
+      postMutation: compileRules(
+        rowRules.update?.postMutation,
         expressionBuilder
       )
     },
@@ -12094,8 +12209,8 @@ function compileCellConfig(cellRules, expressionBuilder) {
       insert: compileRules(rules.insert, expressionBuilder),
       update: {
         preMutation: compileRules(rules.update?.preMutation, expressionBuilder),
-        postProposedMutation: compileRules(
-          rules.update?.postProposedMutation,
+        postMutation: compileRules(
+          rules.update?.postMutation,
           expressionBuilder
         )
       },
@@ -12216,10 +12331,22 @@ var errorKindSchema = valita_exports.union(
   valita_exports.literal("SchemaVersionNotSupported" /* SchemaVersionNotSupported */),
   valita_exports.literal("Internal" /* Internal */)
 );
+var basicErrorBodySchema = valita_exports.object({
+  kind: errorKindSchema,
+  message: valita_exports.string()
+});
+var serverOverloadedBodySchema = valita_exports.object({
+  kind: valita_exports.literal("ServerOverloaded" /* ServerOverloaded */),
+  message: valita_exports.string(),
+  minBackoffMs: valita_exports.number().optional()
+});
+var errorBodySchema = valita_exports.union(
+  basicErrorBodySchema,
+  serverOverloadedBodySchema
+);
 var errorMessageSchema = valita_exports.tuple([
   valita_exports.literal("error"),
-  errorKindSchema,
-  valita_exports.string()
+  errorBodySchema
 ]);
 
 // ../zero-protocol/src/primary-key.ts
@@ -12453,6 +12580,9 @@ var upstreamSchema = valita_exports.union(
   pushMessageSchema
 );
 
+// ../zero-protocol/src/protocol-version.ts
+var PROTOCOL_VERSION = 2;
+
 // ../zero-client/src/util/nanoid.ts
 function nanoid(size = 21) {
   const randomBytes = getNonCryptoRandomValues(new Uint8Array(size));
@@ -14108,47 +14238,6 @@ function constraintMatchesPrimaryKey(constraint, primary) {
   return true;
 }
 
-// ../zql/src/ivm/lookahead-iterator.ts
-var LookaheadIterator = class {
-  #iter;
-  #buffer;
-  #initialized = false;
-  constructor(iter, size = 2) {
-    this.#iter = iter;
-    this.#buffer = new Array(size);
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-  next() {
-    if (!this.#initialized) {
-      for (let i = 0; i < this.#buffer.length; i++) {
-        const r = this.#iter.next();
-        this.#buffer[i] = r.done ? void 0 : r.value;
-      }
-      this.#initialized = true;
-    } else {
-      for (let i = 0; i < this.#buffer.length - 1; i++) {
-        this.#buffer[i] = this.#buffer[i + 1];
-      }
-      const r = this.#iter.next();
-      this.#buffer[this.#buffer.length - 1] = r.done ? void 0 : r.value;
-    }
-    if (this.#buffer[0] === void 0) {
-      return { done: true, value: void 0 };
-    }
-    return { done: false, value: this.#buffer };
-  }
-  return(value) {
-    this.#iter.return?.(value);
-    return { done: true, value: void 0 };
-  }
-  throw(e) {
-    this.#iter.throw?.(e);
-    return { done: true, value: void 0 };
-  }
-};
-
 // ../zql/src/ivm/memory-source.ts
 var MemorySource = class {
   #tableName;
@@ -14185,6 +14274,7 @@ var MemorySource = class {
       columns: this.#columns,
       primaryKey: this.#primaryKey,
       sort: connection.sort,
+      system: "client",
       relationships: {},
       isHidden: false,
       compareRows: connection.compareRows
@@ -14276,7 +14366,8 @@ var MemorySource = class {
       indexSort.push(...requestedSort);
     }
     const index = this.#getOrCreateIndex(indexSort, from);
-    const { data, comparator } = index;
+    const { data, comparator: compare } = index;
+    const comparator = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
     if (this.#overlay) {
       if (callingConnectionNum <= this.#overlay.outputIndex) {
         overlay = this.#overlay;
@@ -14284,37 +14375,11 @@ var MemorySource = class {
     }
     const { constraint } = req;
     const matchesConstraint = constraint ? (row) => constraintMatchesRow(constraint, row) : (_) => true;
-    const predicate = conn.filters?.predicate;
-    const matchesConstraintAndFilters = predicate ? (row) => matchesConstraint(row) && predicate(row) : matchesConstraint;
-    const nextLowerKey = (row) => {
-      if (!row) {
-        return void 0;
-      }
-      let o = overlay;
-      if (o) {
-        if (comparator(o.change.row, row) >= 0) {
-          o = void 0;
-        }
-      }
-      while (row !== void 0) {
-        row = data.nextLowerKey(row);
-        if (row && matchesConstraintAndFilters(row)) {
-          if (o && comparator(o.change.row, row) >= 0) {
-            return o.change.row;
-          }
-          return row;
-        }
-      }
-      return o?.change.row;
-    };
-    let startAt = req.start?.row;
+    const startAt = req.start?.row;
     if (startAt) {
       if (req.constraint) {
         assert(matchesConstraint(startAt), "Start row must match constraint");
       }
-      if (req.start.basis === "before") {
-        startAt = nextLowerKey(startAt);
-      }
     }
     let scanStart;
     if (req.constraint) {
@@ -14323,7 +14388,11 @@ var MemorySource = class {
         if (hasOwn(req.constraint, key)) {
           scanStart[key] = req.constraint[key];
         } else {
-          scanStart[key] = dir === "asc" ? minValue : maxValue;
+          if (req.reverse) {
+            scanStart[key] = dir === "asc" ? maxValue : minValue;
+          } else {
+            scanStart[key] = dir === "asc" ? minValue : maxValue;
+          }
         }
       }
     } else {
@@ -14331,16 +14400,14 @@ var MemorySource = class {
     }
     const withOverlay = generateWithOverlay(
       startAt,
-      // 😬 - btree library doesn't support ideas like start "before" this
-      // key.
-      data.keys(scanStart),
+      generateRows(data, scanStart, req.reverse),
       req.constraint,
       overlay,
       comparator,
       conn.filters?.predicate
     );
     const withConstraint = generateWithConstraint(
-      generateWithStart(withOverlay, req, comparator),
+      generateWithStart(withOverlay, req.start, comparator),
       req.constraint
     );
     yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
@@ -14349,23 +14416,30 @@ var MemorySource = class {
     return this.#fetch(req, connection);
   }
   push(change) {
+    for (const _ of this.genPush(change)) {
+    }
+  }
+  *genPush(change) {
     const primaryIndex = this.#getPrimaryIndex();
     const { data } = primaryIndex;
     switch (change.type) {
       case "add":
-        if (data.has(change.row)) {
-          throw new Error(`Row already exists ${JSON.stringify(change)}`);
-        }
+        assert(
+          !data.has(change.row),
+          () => `Row already exists ${JSON.stringify(change)}`
+        );
         break;
       case "remove":
-        if (!data.has(change.row)) {
-          throw new Error(`Row not found ${JSON.stringify(change)}`);
-        }
+        assert(
+          data.has(change.row),
+          () => `Row not found ${JSON.stringify(change)}`
+        );
         break;
       case "edit":
-        if (!data.has(change.oldRow)) {
-          throw new Error(`Row not found ${JSON.stringify(change)}`);
-        }
+        assert(
+          data.has(change.oldRow),
+          () => `Row not found ${JSON.stringify(change)}`
+        );
         break;
       default:
         unreachable(change);
@@ -14391,6 +14465,7 @@ var MemorySource = class {
       if (output) {
         this.#overlay = { outputIndex, change };
         output.push(outputChange);
+        yield;
       }
     }
     this.#overlay = void 0;
@@ -14433,28 +14508,26 @@ function* generateWithFilter(it, filter) {
     }
   }
 }
-function* generateWithStart(it, req, compare) {
-  const cursor = new LookaheadIterator(it, 2);
-  let started = req.start === void 0 ? true : false;
-  for (const [curr, next] of cursor) {
+function* generateWithStart(nodes, start, compare) {
+  if (!start) {
+    yield* nodes;
+    return;
+  }
+  let started = false;
+  for (const node of nodes) {
     if (!started) {
-      assert(req.start);
-      if (req.start.basis === "before") {
-        if (next === void 0 || compare(next.row, req.start.row) >= 0) {
-          started = true;
-        }
-      } else if (req.start.basis === "at") {
-        if (compare(curr.row, req.start.row) >= 0) {
+      if (start.basis === "at") {
+        if (compare(node.row, start.row) >= 0) {
           started = true;
         }
-      } else if (req.start.basis === "after") {
-        if (compare(curr.row, req.start.row) > 0) {
+      } else if (start.basis === "after") {
+        if (compare(node.row, start.row) > 0) {
           started = true;
         }
       }
     }
     if (started) {
-      yield curr;
+      yield node;
     }
   }
 }
@@ -14581,6 +14654,14 @@ function compareBounds(a, b) {
   }
   return compareValues(a, b);
 }
+function* generateRows(data, scanStart, reverse) {
+  for (const entry of data[reverse ? "entriesReversed" : "entries"](
+    scanStart,
+    []
+  )) {
+    yield entry[0];
+  }
+}
 
 // ../zql/src/ivm/memory-storage.ts
 var MemoryStorage = class {
@@ -14668,7 +14749,7 @@ var ZeroContext = class {
   #commitListeners = /* @__PURE__ */ new Set();
   staticQueryParameters = void 0;
   constructor(tables, addQuery, batchViewUpdates) {
-    this.#tables = tables;
+    this.#tables = normalizeTables(tables);
     this.#addQuery = addQuery;
     this.#batchViewUpdates = batchViewUpdates;
   }
@@ -15219,7 +15300,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.7.2024120200+a7ba44";
+var version2 = "0.7.2024120700+5421b9";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15505,9 +15586,6 @@ var State = class {
   }
 };
 
-// ../zero-client/src/client/protocol-version.ts
-var PROTOCOL_VERSION = 1;
-
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
@@ -15616,9 +15694,7 @@ var QueryManager = class {
       }
     }
     if (gotCallback) {
-      queueMicrotask(() => {
-        gotCallback(this.#gotQueries.has(astHash));
-      });
+      gotCallback(this.#gotQueries.has(astHash));
     }
     let removed = false;
     return () => {
@@ -15734,11 +15810,14 @@ function nextBackoff(lc, now) {
 
 // ../zero-client/src/client/server-error.ts
 var ServerError = class extends Error {
-  kind;
   name = "ServerError";
-  constructor(kind, message) {
-    super(kind + ": " + message);
-    this.kind = kind;
+  errorBody;
+  get kind() {
+    return this.errorBody.kind;
+  }
+  constructor(errorBody) {
+    super(errorBody.kind + ": " + errorBody.message);
+    this.errorBody = errorBody;
   }
 };
 function isServerError(ex) {
@@ -15750,6 +15829,9 @@ function isAuthError(ex) {
 function isAuthErrorKind(kind) {
   return kind === "AuthInvalidated" /* AuthInvalidated */ || kind === "Unauthorized" /* Unauthorized */;
 }
+function isServerOverloadedError(ex) {
+  return isServerError(ex) && ex.errorBody.kind === "ServerOverloaded" /* ServerOverloaded */ ? ex.errorBody : void 0;
+}
 
 // ../zero-client/src/client/server-option.ts
 function validateServerParam(paramName, server) {
@@ -16247,7 +16329,9 @@ var Zero = class {
       ["_zero_crud"]: makeCRUDMutator(normalizedSchema)
     };
     const replicacheOptions = {
-      schemaVersion: normalizedSchema.version.toString(),
+      // The schema stored in IDB is dependent upon both the application schema
+      // and the AST schema (i.e. PROTOCOL_VERSION).
+      schemaVersion: `${normalizedSchema.version}.${PROTOCOL_VERSION}`,
       logLevel: logOptions.logLevel,
       logSinks: [logOptions.logSink],
       mutators: replicacheMutators,
@@ -16529,14 +16613,14 @@ var Zero = class {
   };
   // An error on the connection is fatal for the connection.
   async #handleErrorMessage(lc, downMessage) {
-    const [, kind, message] = downMessage;
+    const [, { kind, message }] = downMessage;
     if (kind === "MutationRateLimited" /* MutationRateLimited */) {
       this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
       lc.error?.("Mutation rate limited", { message });
       return;
     }
     lc.info?.(`${kind}: ${message}}`);
-    const error = new ServerError(kind, message);
+    const error = new ServerError(downMessage[1]);
     this.#rejectMessageError?.reject(error);
     lc.debug?.("Rejecting connect resolver due to error", error);
     this.#connectResolver.reject(error);
@@ -16897,9 +16981,11 @@ var Zero = class {
     await this.#updateAuthToken(bareLogContext);
     let needsReauth = false;
     let gotError = false;
+    let backoffMs = RUN_LOOP_INTERVAL_MS;
     while (!this.closed) {
       runLoopCounter++;
       let lc = getLogContext();
+      backoffMs = RUN_LOOP_INTERVAL_MS;
       try {
         switch (this.#connectionState) {
           case 0 /* Disconnected */: {
@@ -16999,16 +17085,20 @@ 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);
+        }
       }
       if (gotError) {
         this.#setOnline(false);
         lc.debug?.(
           "Sleeping",
-          RUN_LOOP_INTERVAL_MS,
+          backoffMs,
           "ms before reconnecting due to error, state:",
           this.#connectionState
         );
-        await sleep(RUN_LOOP_INTERVAL_MS);
+        await sleep(backoffMs);
       }
     }
   }
@@ -17209,4 +17299,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-KL66XOAW.js.map
+//# sourceMappingURL=chunk-PFF4AHTF.js.map