@rocicorp/zero 0.2.2024101101 → 0.3.2024102300

package/out/zero.js

@@ -9483,20 +9483,72 @@ var Join = class {
       case "child":
         this.#output.push(change);
         break;
-      case "edit":
-        if (normalizeUndefined(change.row[this.#parentKey]) === normalizeUndefined(change.oldRow[this.#parentKey])) {
-          this.#output.push(change);
-        } else {
-          this.#output.push({
-            type: "remove",
-            node: this.#processParentNode(change.oldRow, {}, "cleanup")
+      case "edit": {
+        this.#output.push({
+          type: "edit",
+          row: change.row,
+          oldRow: change.oldRow
+        });
+        const oldKeyValue = normalizeUndefined(change.oldRow[this.#parentKey]);
+        const newKeyValue = normalizeUndefined(change.row[this.#parentKey]);
+        if (newKeyValue !== oldKeyValue) {
+          const childrenToRemoveStream = this.#child.cleanup({
+            constraint: {
+              key: this.#childKey,
+              value: oldKeyValue
+            }
           });
-          this.#output.push({
-            type: "add",
-            node: this.#processParentNode(change.row, {}, "fetch")
+          for (const childNode of childrenToRemoveStream) {
+            this.#output.push({
+              type: "child",
+              // This is the new row since we already changed it in the edit above.
+              row: change.row,
+              child: {
+                relationshipName: this.#relationshipName,
+                change: {
+                  type: "remove",
+                  node: childNode
+                }
+              }
+            });
+          }
+          const childrenToAddStream = this.#child.fetch({
+            constraint: {
+              key: this.#childKey,
+              value: newKeyValue
+            }
           });
+          for (const childNode of childrenToAddStream) {
+            this.#output.push({
+              type: "child",
+              row: change.row,
+              child: {
+                relationshipName: this.#relationshipName,
+                change: {
+                  type: "add",
+                  node: childNode
+                }
+              }
+            });
+          }
+        }
+        const { primaryKey } = this.#parent.getSchema();
+        const oldStorageKey = makeStorageKey(
+          oldKeyValue,
+          primaryKey,
+          change.oldRow
+        );
+        const newStorageKey = makeStorageKey(
+          newKeyValue,
+          primaryKey,
+          change.row
+        );
+        if (oldStorageKey !== newStorageKey) {
+          this.#storage.del(oldStorageKey);
+          this.#storage.set(newStorageKey, true);
         }
         break;
+      }
       default:
         unreachable(change);
     }
@@ -9569,14 +9621,11 @@ var Join = class {
   }
   #processParentNode(parentNodeRow, parentNodeRelations, mode) {
     const parentKeyValue = normalizeUndefined(parentNodeRow[this.#parentKey]);
-    const parentPrimaryKey = [];
-    for (const key of this.#parent.getSchema().primaryKey) {
-      parentPrimaryKey.push(normalizeUndefined(parentNodeRow[key]));
-    }
-    const storageKey = createPrimaryKeySetStorageKey([
+    const storageKey = makeStorageKey(
       parentKeyValue,
-      ...parentPrimaryKey
-    ]);
+      this.#parent.getSchema().primaryKey,
+      parentNodeRow
+    );
     let method = mode;
     if (mode === "cleanup") {
       const [, second] = take(
@@ -9615,6 +9664,13 @@ function createPrimaryKeySetStorageKey(values) {
 function createPrimaryKeySetStorageKeyPrefix(value) {
   return createPrimaryKeySetStorageKey([value]);
 }
+function makeStorageKey(keyValue, primaryKey, row) {
+  const parentPrimaryKey = [keyValue];
+  for (const key of primaryKey) {
+    parentPrimaryKey.push(normalizeUndefined(row[key]));
+  }
+  return createPrimaryKeySetStorageKey(parentPrimaryKey);
+}
 
 // ../zql/src/zql/ivm/skip.ts
 var Skip = class {
@@ -10155,6 +10211,10 @@ function getTakeStateKey(partitionValue) {
   return JSON.stringify(["take", normalizeUndefined(partitionValue)]);
 }
 
+// ../zql/src/zql/builder/error.ts
+var MissingParameterError = class extends Error {
+};
+
 // ../zql/src/zql/builder/like.ts
 function getLikePredicate(pattern, flags) {
   const op = getLikeOp(String(pattern), flags);
@@ -10258,10 +10318,6 @@ function not(f) {
   return (lhs) => !f(lhs);
 }
 
-// ../zql/src/zql/builder/error.ts
-var MissingParameterError = class extends Error {
-};
-
 // ../zql/src/zql/builder/builder.ts
 function buildPipeline(ast, delegate, staticQueryParameters) {
   return buildPipelineInternal(
@@ -10637,6 +10693,11 @@ function makeEntryPreserveRelationships(row, entry, relationships) {
   return result;
 }
 
+// ../shared/src/sorted-entries.ts
+function sortedEntries(object16) {
+  return Object.entries(object16).sort((a, b) => stringCompare(a[0], b[0]));
+}
+
 // ../zql/src/zql/query/schema.ts
 function isFieldRelationship(relationship) {
   return relationship.junction === void 0;
@@ -10645,9 +10706,151 @@ function isJunctionRelationship(relationship) {
   return !isFieldRelationship(relationship);
 }
 
+// ../zql/src/zql/query/normalize-table-schema.ts
+var NormalizedTableSchema = class {
+  tableName;
+  primaryKey;
+  columns;
+  relationships;
+  constructor(tableSchema, tableSchemaCache) {
+    this.tableName = tableSchema.tableName;
+    const primaryKey = normalizePrimaryKey(tableSchema.primaryKey);
+    this.primaryKey = primaryKey;
+    this.columns = normalizeColumns(tableSchema.columns, primaryKey);
+    tableSchemaCache.set(tableSchema, this);
+    this.relationships = normalizeRelationships(
+      tableSchema.relationships,
+      tableSchemaCache
+    );
+  }
+};
+function normalizeTableSchema(tableSchema) {
+  return normalizeTableSchemaWithCache(
+    tableSchema,
+    tableSchema.tableName,
+    /* @__PURE__ */ new Map()
+  );
+}
+function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCache) {
+  if (tableSchema instanceof NormalizedTableSchema) {
+    return tableSchema;
+  }
+  assert(
+    tableSchema.tableName === expectedName,
+    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedName}"`
+  );
+  let normalizedTableSchema = tableSchemaCache.get(tableSchema);
+  if (normalizedTableSchema) {
+    return normalizedTableSchema;
+  }
+  normalizedTableSchema = new NormalizedTableSchema(
+    tableSchema,
+    tableSchemaCache
+  );
+  return normalizedTableSchema;
+}
+function isSorted(arr) {
+  for (let i = 1; i < arr.length; i++) {
+    if (arr[i - 1] >= arr[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertNoDuplicates(arr) {
+  for (let i = 1; i < arr.length; i++) {
+    assert(arr[i - 1] !== arr[i], "Primary key must not contain duplicates");
+  }
+}
+function normalizePrimaryKey(arr) {
+  if (isSorted(arr)) {
+    return arr;
+  }
+  arr = [...arr].sort();
+  assertNoDuplicates(arr);
+  return arr;
+}
+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}`
+    );
+  }
+  for (const [name, column] of sortedEntries(columns)) {
+    rv[name] = normalizeSchemaValue(column);
+  }
+  return rv;
+}
+function normalizeSchemaValue(value) {
+  return {
+    type: value.type,
+    optional: value.optional ?? false
+  };
+}
+function normalizeRelationships(relationships, tableSchemaCache) {
+  const rv = {};
+  for (const [name, relationship] of sortedEntries(relationships)) {
+    rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+  }
+  return rv;
+}
+function normalizeRelationship(relationship, tableSchemaCache) {
+  if (isFieldRelationship(relationship)) {
+    return normalizeFieldRelationship(relationship, tableSchemaCache);
+  }
+  return normalizeJunctionRelationship(relationship, tableSchemaCache);
+}
+function normalizeFieldRelationship(relationship, tableSchemaCache) {
+  return {
+    source: relationship.source,
+    dest: {
+      field: relationship.dest.field,
+      schema: normalizeLazyTableSchema(
+        relationship.dest.schema,
+        tableSchemaCache
+      )
+    }
+  };
+}
+function normalizeJunctionRelationship(relationship, tableSchemaCache) {
+  return {
+    source: relationship.source,
+    junction: {
+      sourceField: relationship.junction.sourceField,
+      destField: relationship.junction.destField,
+      schema: normalizeLazyTableSchema(
+        relationship.junction.schema,
+        tableSchemaCache
+      )
+    },
+    dest: {
+      field: relationship.dest.field,
+      schema: normalizeLazyTableSchema(
+        relationship.dest.schema,
+        tableSchemaCache
+      )
+    }
+  };
+}
+function normalizeLazyTableSchema(tableSchema, buildCache) {
+  const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
+  return normalizeTableSchemaWithCache(
+    tableSchemaInstance,
+    tableSchemaInstance.tableName,
+    // Don't care about name here.
+    buildCache
+  );
+}
+
 // ../zql/src/zql/query/query-impl.ts
 function newQuery(delegate, tableSchema) {
-  return new QueryImpl(delegate, tableSchema);
+  return new QueryImpl(delegate, normalizeTableSchema(tableSchema));
 }
 function newQueryWithDetails(delegate, schema, ast, format) {
   return new QueryImpl(delegate, schema, ast, format);
@@ -10688,7 +10891,7 @@ var AbstractQuery = class {
     const related1 = related;
     const related2 = related;
     if (isFieldRelationship(related1)) {
-      const destSchema = resolveSchema(related1.dest.schema);
+      const destSchema = related1.dest.schema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -10725,8 +10928,8 @@ var AbstractQuery = class {
       );
     }
     if (isJunctionRelationship(related2)) {
-      const destSchema = resolveSchema(related2.dest.schema);
-      const junctionSchema = resolveSchema(related2.junction.schema);
+      const destSchema = related2.dest.schema;
+      const junctionSchema = related2.junction.schema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -10913,12 +11116,6 @@ var QueryImpl = class extends AbstractQuery {
     };
   }
 };
-function resolveSchema(maybeSchema) {
-  if (typeof maybeSchema === "function") {
-    return maybeSchema();
-  }
-  return maybeSchema;
-}
 function addPrimaryKeys(schema, orderBy) {
   orderBy = orderBy ?? [];
   const { primaryKey } = schema;
@@ -10946,6 +11143,7 @@ import { LogContext as LogContext3 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
 // ../zero-protocol/src/ast.ts
+import { compareUTF8 as compareUTF84 } from "compare-utf8";
 var selectorSchema = valita_exports.string();
 var orderingElementSchema = readonly(
   valita_exports.tuple([selectorSchema, valita_exports.union(valita_exports.literal("asc"), valita_exports.literal("desc"))])
@@ -11020,6 +11218,57 @@ var astSchema = valita_exports.object({
     exclusive: valita_exports.boolean()
   }).optional()
 });
+function normalizeAST(ast) {
+  return {
+    schema: ast.schema,
+    table: ast.table,
+    alias: ast.alias,
+    where: ast.where ? sortedWhere(ast.where) : void 0,
+    related: ast.related ? sortedRelated(
+      ast.related.map(
+        (r) => ({
+          correlation: {
+            parentField: r.correlation.parentField,
+            childField: r.correlation.childField,
+            op: r.correlation.op
+          },
+          hidden: r.hidden,
+          subquery: normalizeAST(r.subquery)
+        })
+      )
+    ) : void 0,
+    start: ast.start,
+    limit: ast.limit,
+    orderBy: ast.orderBy
+  };
+}
+function sortedWhere(where) {
+  return [...where].sort(cmpCondition);
+}
+function sortedRelated(related) {
+  return related.sort(cmpRelated);
+}
+function cmpCondition(a, b) {
+  return compareUTF8MaybeNull(a.field, b.field) || compareUTF8MaybeNull(a.op, b.op) || // Comparing the same field with the same op more than once doesn't make logical
+  // sense, but is technically possible. Assume the values are of the same type and
+  // sort by their String forms.
+  compareUTF8MaybeNull(String(a.value), String(b.value));
+}
+function cmpRelated(a, b) {
+  return compareUTF84(must(a.subquery.alias), must(b.subquery.alias));
+}
+function compareUTF8MaybeNull(a, b) {
+  if (a !== null && b !== null) {
+    return compareUTF84(a, b);
+  }
+  if (b !== null) {
+    return -1;
+  }
+  if (a !== null) {
+    return 1;
+  }
+  return 0;
+}
 
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
@@ -11077,6 +11326,13 @@ var initConnectionMessageSchema = valita_exports.tuple([
   valita_exports.literal("initConnection"),
   initConnectionBodySchema
 ]);
+function encodeSecProtocols(initConnectionMessage, authToken) {
+  const protocols = [btoa(JSON.stringify(initConnectionMessage))];
+  if (authToken !== void 0) {
+    protocols.push(authToken);
+  }
+  return encodeURIComponent(protocols.join(","));
+}
 
 // ../zero-protocol/src/error.ts
 var errorKindSchema = valita_exports.union(
@@ -11101,12 +11357,20 @@ var errorMessageSchema = valita_exports.tuple([
   valita_exports.string()
 ]);
 
-// ../zero-protocol/src/version.ts
-var versionSchema = valita_exports.string();
-var nullableVersionSchema = valita_exports.union(versionSchema, valita_exports.null());
+// ../zero-protocol/src/data.ts
+var valueSchema = valita_exports.union(
+  valita_exports.null(),
+  valita_exports.boolean(),
+  valita_exports.number(),
+  valita_exports.string(),
+  valita_exports.undefined()
+);
+var rowSchema = valita_exports.record(valueSchema);
 
 // ../zero-protocol/src/primary-key.ts
-var primaryKeySchema = valita_exports.array(valita_exports.string()).assert((arr) => arr.length > 0);
+var primaryKeySchema = readonly(
+  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
+);
 var primaryKeyValueSchema = valita_exports.union(
   valita_exports.string(),
   valita_exports.number(),
@@ -11116,35 +11380,38 @@ var primaryKeyValueRecordSchema = readonlyRecord(
   primaryKeyValueSchema
 );
 
-// ../zero-protocol/src/entities-patch.ts
+// ../zero-protocol/src/row-patch.ts
 var putOpSchema3 = valita_exports.object({
   op: valita_exports.literal("put"),
-  entityType: valita_exports.string(),
-  entityID: primaryKeyValueRecordSchema,
-  value: jsonObjectSchema
+  tableName: valita_exports.string(),
+  value: rowSchema
 });
 var updateOpSchema = valita_exports.object({
   op: valita_exports.literal("update"),
-  entityType: valita_exports.string(),
-  entityID: primaryKeyValueRecordSchema,
+  tableName: valita_exports.string(),
+  id: primaryKeyValueRecordSchema,
   merge: jsonObjectSchema.optional(),
   constrain: valita_exports.array(valita_exports.string()).optional()
 });
 var delOpSchema3 = valita_exports.object({
   op: valita_exports.literal("del"),
-  entityType: valita_exports.string(),
-  entityID: primaryKeyValueRecordSchema
+  tableName: valita_exports.string(),
+  id: primaryKeyValueRecordSchema
 });
 var clearOpSchema3 = valita_exports.object({
   op: valita_exports.literal("clear")
 });
-var entityPatchOpSchema = valita_exports.union(
+var rowPatchOpSchema = valita_exports.union(
   putOpSchema3,
   updateOpSchema,
   delOpSchema3,
   clearOpSchema3
 );
-var entitiesPatchSchema = valita_exports.array(entityPatchOpSchema);
+var rowsPatchSchema = valita_exports.array(rowPatchOpSchema);
+
+// ../zero-protocol/src/version.ts
+var versionSchema = valita_exports.string();
+var nullableVersionSchema = valita_exports.union(versionSchema, valita_exports.null());
 
 // ../zero-protocol/src/poke.ts
 var pokeStartBodySchema = valita_exports.object({
@@ -11170,13 +11437,16 @@ var pokePartBodySchema = valita_exports.object({
   // Patches to the desired query sets by client id.
   desiredQueriesPatches: valita_exports.record(queriesPatchSchema).optional(),
   // Patches to the set of queries for which entities are sync'd in
-  // entitiesPatch.
+  // rowsPatch.
   gotQueriesPatch: queriesPatchSchema.optional(),
-  // Patches to the entities set.
-  entitiesPatch: entitiesPatchSchema.optional()
+  // Patches to the rows set.
+  rowsPatch: rowsPatchSchema.optional()
 });
 var pokeEndBodySchema = valita_exports.object({
-  pokeID: valita_exports.string()
+  pokeID: valita_exports.string(),
+  // If `true`, the poke with id `pokeID` should be discarded without
+  // applying it.
+  cancel: valita_exports.boolean().optional()
 });
 var pokeStartMessageSchema = valita_exports.tuple([
   valita_exports.literal("pokeStart"),
@@ -11218,9 +11488,16 @@ var pullResponseMessageSchema = valita_exports.tuple([
   pullResponseBodySchema
 ]);
 
+// ../zero-protocol/src/warm.ts
+var warmBodySchema = valita_exports.object({
+  payload: valita_exports.string()
+});
+var warmMessageSchema = valita_exports.tuple([valita_exports.literal("warm"), warmBodySchema]);
+
 // ../zero-protocol/src/down.ts
 var downstreamSchema = valita_exports.union(
   connectedMessageSchema,
+  warmMessageSchema,
   errorMessageSchema,
   pongMessageSchema,
   pokeStartMessageSchema,
@@ -11237,26 +11514,29 @@ var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pi
 var CRUD_MUTATION_NAME = "_zero_crud";
 var createOpSchema = valita_exports.object({
   op: valita_exports.literal("create"),
-  entityType: valita_exports.string(),
-  id: primaryKeyValueRecordSchema,
-  value: jsonObjectSchema
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  value: rowSchema
 });
 var setOpSchema = valita_exports.object({
   op: valita_exports.literal("set"),
-  entityType: valita_exports.string(),
-  id: primaryKeyValueRecordSchema,
-  value: jsonObjectSchema
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  value: rowSchema
 });
 var updateOpSchema2 = valita_exports.object({
   op: valita_exports.literal("update"),
-  entityType: valita_exports.string(),
-  id: primaryKeyValueRecordSchema,
-  partialValue: jsonObjectSchema
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  // Partial value with at least the primary key fields
+  value: rowSchema
 });
 var deleteOpSchema = valita_exports.object({
   op: valita_exports.literal("delete"),
-  entityType: valita_exports.string(),
-  id: primaryKeyValueRecordSchema
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  // Partial value representing the primary key
+  value: primaryKeyValueRecordSchema
 });
 var crudOpSchema = valita_exports.union(
   createOpSchema,
@@ -13478,21 +13758,12 @@ function desiredQueriesPrefixForClient(clientID) {
 function toGotQueriesKey(hash2) {
   return GOT_QUERIES_KEY_PREFIX + hash2;
 }
-function maybeSort(arr) {
-  for (let i = 1; i < arr.length; i++) {
-    if (arr[i] < arr[i - 1]) {
-      return [...arr].sort();
-    }
-  }
-  return arr;
-}
-function toPrimaryKeyString(tableName, primaryKey, id) {
+function toPrimaryKeyString(tableName, primaryKey, value) {
   if (primaryKey.length === 1) {
-    return ENTITIES_KEY_PREFIX + tableName + "/" + id[primaryKey[0]];
+    return ENTITIES_KEY_PREFIX + tableName + "/" + parse(value[primaryKey[0]], primaryKeyValueSchema);
   }
-  const sorted = maybeSort(primaryKey);
-  const arr = sorted.map((k) => id[k]);
-  const str = JSON.stringify(arr);
+  const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
+  const str = JSON.stringify(values);
   const idSegment = h64WithReverse(str);
   return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
 }
@@ -13583,15 +13854,6 @@ var ZeroContext = class {
   }
 };
 
-// ../zero-client/src/client/make-id-from-primary-key.ts
-function makeIDFromPrimaryKey(primaryKey, value) {
-  const id = {};
-  for (const key of primaryKey) {
-    id[key] = parse(value[key], primaryKeyValueSchema);
-  }
-  return id;
-}
-
 // ../zero-client/src/client/crud.ts
 function makeCRUDMutate(schema, repMutate) {
   const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
@@ -13614,9 +13876,9 @@ function makeCRUDMutate(schema, repMutate) {
       inBatch = false;
     }
   };
-  const assertNotInBatch = (entityType, op) => {
+  const assertNotInBatch = (tableName, op) => {
     if (inBatch) {
-      throw new Error(`Cannot call mutate.${entityType}.${op} inside a batch`);
+      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
     }
   };
   for (const [name, tableSchema] of Object.entries(schema.tables)) {
@@ -13629,44 +13891,45 @@ function makeCRUDMutate(schema, repMutate) {
   }
   return mutate;
 }
-function makeEntityCRUDMutate(entityType, primaryKey, zeroCRUD, assertNotInBatch) {
+function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
   return {
     create: (value) => {
-      assertNotInBatch(entityType, "create");
+      assertNotInBatch(tableName, "create");
       const op = {
         op: "create",
-        entityType,
-        id: makeIDFromPrimaryKey(primaryKey, value),
+        tableName,
+        primaryKey,
         value
       };
       return zeroCRUD({ ops: [op] });
     },
     set: (value) => {
-      assertNotInBatch(entityType, "set");
+      assertNotInBatch(tableName, "set");
       const op = {
         op: "set",
-        entityType,
-        id: makeIDFromPrimaryKey(primaryKey, value),
+        tableName,
+        primaryKey,
         value
       };
       return zeroCRUD({ ops: [op] });
     },
     update: (value) => {
-      assertNotInBatch(entityType, "update");
+      assertNotInBatch(tableName, "update");
       const op = {
         op: "update",
-        entityType,
-        id: makeIDFromPrimaryKey(primaryKey, value),
-        partialValue: value
+        tableName,
+        primaryKey,
+        value
       };
       return zeroCRUD({ ops: [op] });
     },
     delete: (id) => {
-      assertNotInBatch(entityType, "delete");
+      assertNotInBatch(tableName, "delete");
       const op = {
         op: "delete",
-        entityType,
-        id: makeIDFromPrimaryKey(primaryKey, id)
+        tableName,
+        primaryKey,
+        value: id
       };
       return zeroCRUD({ ops: [op] });
     }
@@ -13678,8 +13941,8 @@ function makeBatchCRUDMutate(tableName, schema, ops) {
     create: (value) => {
       const op = {
         op: "create",
-        entityType: tableName,
-        id: makeIDFromPrimaryKey(primaryKey, value),
+        tableName,
+        primaryKey,
         value
       };
       ops.push(op);
@@ -13688,8 +13951,8 @@ function makeBatchCRUDMutate(tableName, schema, ops) {
     set: (value) => {
       const op = {
         op: "set",
-        entityType: tableName,
-        id: makeIDFromPrimaryKey(primaryKey, value),
+        tableName,
+        primaryKey,
         value
       };
       ops.push(op);
@@ -13698,9 +13961,9 @@ function makeBatchCRUDMutate(tableName, schema, ops) {
     update: (value) => {
       const op = {
         op: "update",
-        entityType: tableName,
-        id: makeIDFromPrimaryKey(primaryKey, value),
-        partialValue: value
+        tableName,
+        primaryKey,
+        value
       };
       ops.push(op);
       return promiseVoid;
@@ -13708,8 +13971,9 @@ function makeBatchCRUDMutate(tableName, schema, ops) {
     delete: (id) => {
       const op = {
         op: "delete",
-        entityType: tableName,
-        id: makeIDFromPrimaryKey(primaryKey, id)
+        tableName,
+        primaryKey,
+        value: id
       };
       ops.push(op);
       return promiseVoid;
@@ -13738,9 +14002,9 @@ function makeCRUDMutator(schema) {
 }
 async function createImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
-    arg.entityType,
-    schema.tables[arg.entityType].primaryKey,
-    arg.id
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
   if (!await tx.has(key)) {
     await tx.set(key, arg.value);
@@ -13748,31 +14012,31 @@ async function createImpl(tx, arg, schema) {
 }
 async function setImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
-    arg.entityType,
-    schema.tables[arg.entityType].primaryKey,
-    arg.id
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
   await tx.set(key, arg.value);
 }
 async function updateImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
-    arg.entityType,
-    schema.tables[arg.entityType].primaryKey,
-    arg.id
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
   const prev = await tx.get(key);
   if (prev === void 0) {
     return;
   }
-  const update = arg.partialValue;
+  const update = arg.value;
   const next = { ...prev, ...update };
   await tx.set(key, next);
 }
 async function deleteImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
-    arg.entityType,
-    schema.tables[arg.entityType].primaryKey,
-    arg.id
+    arg.tableName,
+    schema.tables[arg.tableName].primaryKey,
+    arg.value
   );
   await tx.del(key);
 }
@@ -14308,58 +14572,28 @@ var State = class {
   }
 };
 
-// ../zql/src/zql/ast/ast.ts
-import { compareUTF8 as compareUTF84 } from "compare-utf8";
-function normalizeAST(ast) {
-  return {
-    schema: ast.schema,
-    table: ast.table,
-    alias: ast.alias,
-    where: ast.where ? sortedWhere(ast.where) : void 0,
-    related: ast.related ? sortedRelated(
-      ast.related.map(
-        (r) => ({
-          correlation: {
-            parentField: r.correlation.parentField,
-            childField: r.correlation.childField,
-            op: r.correlation.op
-          },
-          hidden: r.hidden,
-          subquery: normalizeAST(r.subquery)
-        })
-      )
-    ) : void 0,
-    start: ast.start,
-    limit: ast.limit,
-    orderBy: ast.orderBy
-  };
-}
-function sortedWhere(where) {
-  return [...where].sort(cmpCondition);
-}
-function sortedRelated(related) {
-  return related.sort(cmpRelated);
-}
-function cmpCondition(a, b) {
-  return compareUTF8MaybeNull(a.field, b.field) || compareUTF8MaybeNull(a.op, b.op) || // Comparing the same field with the same op more than once doesn't make logical
-  // sense, but is technically possible. Assume the values are of the same type and
-  // sort by their String forms.
-  compareUTF8MaybeNull(String(a.value), String(b.value));
-}
-function cmpRelated(a, b) {
-  return compareUTF84(must(a.subquery.alias), must(b.subquery.alias));
-}
-function compareUTF8MaybeNull(a, b) {
-  if (a !== null && b !== null) {
-    return compareUTF84(a, b);
+// ../zero-client/src/client/normalized-schema.ts
+function normalizeSchema(schema) {
+  if (schema instanceof NormalizedSchema) {
+    return schema;
   }
-  if (b !== null) {
-    return -1;
+  return new NormalizedSchema(schema);
+}
+var NormalizedSchema = class {
+  version;
+  tables;
+  constructor(schema) {
+    this.version = schema.version;
+    this.tables = normalizeTables(schema.tables);
   }
-  if (a !== null) {
-    return 1;
+};
+function normalizeTables(tables) {
+  const rv = {};
+  const tableSchemaCache = /* @__PURE__ */ new Map();
+  for (const [name, table] of sortedEntries(tables)) {
+    rv[name] = normalizeTableSchemaWithCache(table, name, tableSchemaCache);
   }
-  return 0;
+  return rv;
 }
 
 // ../zero-client/src/client/query-manager.ts
@@ -14399,21 +14633,49 @@ var QueryManager = class {
       gotCallback(got);
     }
   }
-  async getQueriesPatch(tx) {
+  /**
+   * Get the queries that need to be registered with the server.
+   *
+   * An optional `lastPatch` can be provided. This is the last patch that was
+   * sent to the server and may not yet have been acked. If `lastPatch` is provided,
+   * this method will return a patch that does not include any events sent in `lastPatch`.
+   *
+   * This diffing of last patch and current patch is needed since we send
+   * a set of queries to the server when we first connect inside of the `sec-protocol` as
+   * the `initConnectionMessage`.
+   *
+   * While we're waiting for the `connected` response to come back from the server,
+   * the client may have registered more queries. We need to diff the `initConnectionMessage`
+   * queries with the current set of queries to understand what those were.
+   */
+  async getQueriesPatch(tx, lastPatch) {
     const existingQueryHashes = /* @__PURE__ */ new Set();
     const prefix = desiredQueriesPrefixForClient(this.#clientID);
     for await (const key of tx.scan({ prefix }).keys()) {
       existingQueryHashes.add(key.substring(prefix.length, key.length));
     }
-    const patch = [];
+    const patch = /* @__PURE__ */ new Map();
     for (const hash2 of existingQueryHashes) {
       if (!this.#queries.has(hash2)) {
-        patch.push({ op: "del", hash: hash2 });
+        patch.set(hash2, { op: "del", hash: hash2 });
       }
     }
     for (const [hash2, { normalized }] of this.#queries) {
       if (!existingQueryHashes.has(hash2)) {
-        patch.push({ op: "put", hash: hash2, ast: normalized });
+        patch.set(hash2, { op: "put", hash: hash2, ast: normalized });
+      }
+    }
+    if (lastPatch) {
+      for (const [hash2, { op }] of lastPatch) {
+        if (op === "put" && !patch.has(hash2)) {
+          patch.set(hash2, { op: "del", hash: hash2 });
+        }
+      }
+      for (const [hash2, { op }] of patch) {
+        const lastPatchOp = lastPatch.get(hash2);
+        if (lastPatchOp && lastPatchOp.op === op) {
+          patch.delete(hash2);
+        }
       }
     }
     return patch;
@@ -14614,6 +14876,10 @@ var PokeHandler = class {
       );
       return;
     }
+    if (pokeEnd.cancel) {
+      this.#receivingPoke = void 0;
+      return;
+    }
     this.#pokeBuffer.push(this.#receivingPoke);
     this.#receivingPoke = void 0;
     if (!this.#pokePlaybackLoopRunning) {
@@ -14733,10 +14999,10 @@ function mergePokes(pokeBuffer, schema) {
           )
         );
       }
-      if (pokePart.entitiesPatch) {
+      if (pokePart.rowsPatch) {
         mergedPatch.push(
-          ...pokePart.entitiesPatch.map(
-            (p) => entitiesPatchOpToReplicachePatchOp(p, schema)
+          ...pokePart.rowsPatch.map(
+            (p) => rowsPatchOpToReplicachePatchOp(p, schema)
           )
         );
       }
@@ -14787,7 +15053,7 @@ function queryPatchOpToReplicachePatchOp(op, toKey) {
       };
   }
 }
-function entitiesPatchOpToReplicachePatchOp(op, schema) {
+function rowsPatchOpToReplicachePatchOp(op, schema) {
   switch (op.op) {
     case "clear":
       return op;
@@ -14795,18 +15061,18 @@ function entitiesPatchOpToReplicachePatchOp(op, schema) {
       return {
         op: "del",
         key: toPrimaryKeyString(
-          op.entityType,
-          schema.tables[op.entityType].primaryKey,
-          op.entityID
+          op.tableName,
+          schema.tables[op.tableName].primaryKey,
+          op.id
         )
       };
     case "put":
       return {
         op: "put",
         key: toPrimaryKeyString(
-          op.entityType,
-          schema.tables[op.entityType].primaryKey,
-          op.entityID
+          op.tableName,
+          schema.tables[op.tableName].primaryKey,
+          op.value
         ),
         value: op.value
       };
@@ -14814,9 +15080,9 @@ function entitiesPatchOpToReplicachePatchOp(op, schema) {
       return {
         op: "update",
         key: toPrimaryKeyString(
-          op.entityType,
-          schema.tables[op.entityType].primaryKey,
-          op.entityID
+          op.tableName,
+          schema.tables[op.tableName].primaryKey,
+          op.id
         ),
         merge: op.merge,
         constrain: op.constrain
@@ -14880,6 +15146,13 @@ var Zero = class {
   #enableAnalytics;
   #pokeHandler;
   #queryManager;
+  /**
+   * The queries we sent when establishing a connection.
+   * More queries could be registered while we're waiting for the 'connected' message
+   * to come back from the server. To understand what queries we need to send
+   * to the server, we diff the `initConnectionQueries` with the current set of desired queries.
+   */
+  #initConnectionQueries = /* @__PURE__ */ new Map();
   #lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
   #onPong = () => void 0;
   #online = false;
@@ -15030,11 +15303,12 @@ var Zero = class {
       enableAnalytics: this.#enableAnalytics
     });
     const logOptions = this.#logOptions;
+    const normalizedSchema = normalizeSchema(schema);
     const replicacheMutators = {
-      ["_zero_crud"]: makeCRUDMutator(schema)
+      ["_zero_crud"]: makeCRUDMutator(normalizedSchema)
     };
     const replicacheOptions = {
-      schemaVersion: schema.version.toString(),
+      schemaVersion: normalizedSchema.version.toString(),
       logLevel: logOptions.logLevel,
       logSinks: [logOptions.logSink],
       mutators: replicacheMutators,
@@ -15080,14 +15354,14 @@ var Zero = class {
         reason ?? ON_CLIENT_STATE_NOT_FOUND_REASON_CLIENT
       );
     };
-    this.mutate = makeCRUDMutate(schema, rep.mutate);
+    this.mutate = makeCRUDMutate(normalizedSchema, rep.mutate);
     this.#queryManager = new QueryManager(
       rep.clientID,
       (msg) => this.#sendChangeDesiredQueries(msg),
       rep.experimentalWatch.bind(rep)
     );
     this.#zeroContext = new ZeroContext(
-      schema.tables,
+      normalizedSchema.tables,
       (ast, gotCallback) => this.#queryManager.add(ast, gotCallback)
     );
     rep.experimentalWatch(
@@ -15097,7 +15371,7 @@ var Zero = class {
         initialValuesInFirstDiff: true
       }
     );
-    this.query = this.#registerQueries(schema);
+    this.query = this.#registerQueries(normalizedSchema);
     reportReloadReason(this.#lc);
     this.#metrics = new MetricManager({
       reportIntervalMs: REPORT_INTERVAL_MS,
@@ -15111,7 +15385,7 @@ var Zero = class {
       (poke) => this.#rep.poke(poke),
       () => this.#onPokeError(),
       rep.clientID,
-      schema,
+      normalizedSchema,
       this.#lc
     );
     this.#visibilityWatcher = getDocumentVisibilityWatcher(
@@ -15244,7 +15518,8 @@ var Zero = class {
       return;
     }
     this.#messageCount++;
-    switch (downMessage[0]) {
+    const msgType = downMessage[0];
+    switch (msgType) {
       case "connected":
         return this.#handleConnectedMessage(lc, downMessage);
       case "error":
@@ -15259,7 +15534,10 @@ var Zero = class {
         return this.#handlePokeEnd(lc, downMessage);
       case "pull":
         return this.#handlePullResponse(lc, downMessage);
+      case "warm":
+        break;
       default:
+        msgType;
         rejectInvalidMessage();
     }
   };
@@ -15365,16 +15643,19 @@ var Zero = class {
     });
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     lc.debug?.("Resolving connect resolver");
+    assert(this.#socket);
     const queriesPatch = await this.#rep.query(
-      (tx) => this.#queryManager.getQueriesPatch(tx)
+      (tx) => this.#queryManager.getQueriesPatch(tx, this.#initConnectionQueries)
     );
-    assert(this.#socket);
-    send(this.#socket, [
-      "initConnection",
-      {
-        desiredQueriesPatch: queriesPatch
-      }
-    ]);
+    if (queriesPatch.size > 0) {
+      send(this.#socket, [
+        "changeDesiredQueries",
+        {
+          desiredQueriesPatch: [...queriesPatch.values()]
+        }
+      ]);
+    }
+    this.#initConnectionQueries = /* @__PURE__ */ new Map();
     this.#setConnectionState(2 /* Connected */);
     this.#connectResolver.resolve();
   }
@@ -15428,7 +15709,9 @@ var Zero = class {
       clearTimeout(timeoutID);
     };
     this.#closeAbortController.signal.addEventListener("abort", abortHandler);
-    const ws = createSocket(
+    const [ws, initConnectionQueries] = await createSocket(
+      this.#rep,
+      this.#queryManager,
       toWSString(this.#server),
       this.#connectCookie,
       this.clientID,
@@ -15445,6 +15728,7 @@ var Zero = class {
     if (this.closed) {
       return;
     }
+    this.#initConnectionQueries = initConnectionQueries;
     ws.addEventListener("message", this.#onMessage);
     ws.addEventListener("open", this.#onOpen);
     ws.addEventListener("close", this.#onClose);
@@ -15908,7 +16192,7 @@ var Zero = class {
     return rv;
   }
 };
-function createSocket(socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, jurisdiction, lmid, wsid, debugPerf, lc) {
+async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, jurisdiction, lmid, wsid, debugPerf, lc) {
   const url = new URL(socketOrigin);
   url.pathname = `/api/sync/v${REFLECT_VERSION}/connect`;
   const { searchParams } = url;
@@ -15928,11 +16212,18 @@ function createSocket(socketOrigin, baseCookie, clientID, clientGroupID, schemaV
   }
   lc.info?.("Connecting to", url.toString());
   const WS = mustGetBrowserGlobal("WebSocket");
-  return new WS(
-    // toString() required for RN URL polyfill.
-    url.toString(),
-    auth === "" || auth === void 0 ? void 0 : encodeURIComponent(auth)
-  );
+  const queriesPatch = await rep.query((tx) => queryManager.getQueriesPatch(tx));
+  return [
+    new WS(
+      // toString() required for RN URL polyfill.
+      url.toString(),
+      encodeSecProtocols(
+        ["initConnection", { desiredQueriesPatch: [...queriesPatch.values()] }],
+        auth
+      )
+    ),
+    queriesPatch
+  ];
 }
 function addWebSocketIDFromSocketToLogContext({ url }, lc) {
   const wsid = new URL(url).searchParams.get("wsid") ?? nanoid();