@rocicorp/zero 0.5.2024110200 → 0.6.2024111700

package/out/{chunk-INJ4WJHS.js → chunk-PIFWXXO2.js}

@@ -14,7 +14,7 @@ import {
   must,
   throwInvalidType,
   unreachable
-} from "./chunk-YCMA66NH.js";
+} from "./chunk-5UY46OAF.js";
 import {
   __export,
   __reExport
@@ -564,6 +564,9 @@ var WriteImplBase = class {
 function getBrowserGlobal(name) {
   return globalThis[name];
 }
+function getBrowserGlobalMethod(name) {
+  return globalThis[name]?.bind(globalThis);
+}
 function mustGetBrowserGlobal(name) {
   const r = getBrowserGlobal(name);
   if (r === void 0) {
@@ -9236,121 +9239,186 @@ function getKVStoreProvider(lc, kvStore) {
 // ../replicache/src/mod.ts
 import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
 
-// ../zql/src/query/expression.ts
-function cmp(field, opOrValue, value) {
-  let op;
-  if (value === void 0) {
-    value = opOrValue;
-    op = "=";
-  } else {
-    op = opOrValue;
+// ../zero-schema/src/table-schema.ts
+function createTableSchema(schema) {
+  return schema;
+}
+function isFieldRelationship(relationship) {
+  return relationship.junction === void 0;
+}
+function isJunctionRelationship(relationship) {
+  return !isFieldRelationship(relationship);
+}
+
+// ../shared/src/sorted-entries.ts
+function sortedEntries(object16) {
+  return Object.entries(object16).sort((a, b) => stringCompare(a[0], b[0]));
+}
+
+// ../zero-schema/src/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
+    );
   }
-  return {
-    type: "simple",
-    field,
-    op,
-    value
-  };
+};
+function normalizeTableSchema(tableSchema) {
+  return normalizeTableSchemaWithCache(
+    tableSchema,
+    tableSchema.tableName,
+    /* @__PURE__ */ new Map()
+  );
 }
-function and(...conditions) {
-  if (conditions.length === 1) {
-    return conditions[0];
+function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCache) {
+  if (tableSchema instanceof NormalizedTableSchema) {
+    return tableSchema;
   }
-  const ands = conditions.flatMap((c) => {
-    if (c.type === "and") {
-      return c.conditions;
-    } else if (c.type === "simple") {
-      return [c];
-    }
-    return [];
-  });
-  const ors = conditions.filter(
-    (c) => c.type === "or"
+  assert(
+    tableSchema.tableName === expectedName,
+    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedName}"`
+  );
+  let normalizedTableSchema = tableSchemaCache.get(tableSchema);
+  if (normalizedTableSchema) {
+    return normalizedTableSchema;
+  }
+  normalizedTableSchema = new NormalizedTableSchema(
+    tableSchema,
+    tableSchemaCache
   );
-  if (ors.length === 0) {
-    return { type: "and", conditions: ands };
+  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}`
+    );
   }
-  const flatOrs = flatten("or", ors);
-  const flatAnds = flatten("and", ands);
+  for (const [name, column] of sortedEntries(columns)) {
+    rv[name] = normalizeSchemaValue(column);
+  }
+  return rv;
+}
+function normalizeSchemaValue(value) {
   return {
-    type: "or",
-    conditions: flatOrs.conditions.map((part) => ({
-      type: "and",
-      conditions: [
-        ...part.type === "and" ? part.conditions : [part],
-        ...flatAnds.conditions
-      ]
-    }))
+    type: value.type,
+    optional: value.optional ?? false
   };
 }
-function or(...conditions) {
-  if (conditions.length === 1) {
-    return conditions[0];
+function normalizeRelationships(relationships, tableSchemaCache) {
+  const rv = {};
+  for (const [name, relationship] of sortedEntries(relationships)) {
+    rv[name] = normalizeRelationship(relationship, tableSchemaCache);
   }
-  return flatten("or", conditions);
+  return rv;
 }
-function not(expr) {
-  switch (expr.type) {
-    case "and":
-      return {
-        type: "or",
-        conditions: expr.conditions.map(not)
-      };
-    case "or":
-      return {
-        type: "and",
-        conditions: expr.conditions.map(not)
-      };
-    default:
-      return {
-        type: "simple",
-        op: negateOperator(expr.op),
-        field: expr.field,
-        value: expr.value
-      };
+function normalizeRelationship(relationship, tableSchemaCache) {
+  if (isFieldRelationship(relationship)) {
+    return normalizeFieldRelationship(relationship, tableSchemaCache);
   }
+  return normalizeJunctionRelationship(relationship, tableSchemaCache);
 }
-function flatten(type, conditions) {
-  const flattened2 = [];
-  for (const c of conditions) {
-    if (c.type === type) {
-      flattened2.push(...c.conditions);
-    } else {
-      flattened2.push(c);
+function normalizeFieldRelationship(relationship, tableSchemaCache) {
+  return {
+    source: relationship.source,
+    dest: {
+      field: relationship.dest.field,
+      schema: normalizeLazyTableSchema(
+        relationship.dest.schema,
+        tableSchemaCache
+      )
     }
-  }
+  };
+}
+function normalizeJunctionRelationship(relationship, tableSchemaCache) {
   return {
-    type,
-    conditions: flattened2
+    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 negateOperator(op) {
-  switch (op) {
-    case "=":
-      return "!=";
-    case "!=":
-      return "=";
-    case "<":
-      return ">=";
-    case ">":
-      return "<=";
-    case ">=":
-      return "<";
-    case "<=":
-      return ">";
-    case "IN":
-      return "NOT IN";
-    case "NOT IN":
-      return "IN";
-    case "LIKE":
-      return "NOT LIKE";
-    case "NOT LIKE":
-      return "LIKE";
-    case "ILIKE":
-      return "NOT ILIKE";
-    case "NOT ILIKE":
-      return "ILIKE";
+function normalizeLazyTableSchema(tableSchema, buildCache) {
+  const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
+  return normalizeTableSchemaWithCache(
+    tableSchemaInstance,
+    tableSchemaInstance.tableName,
+    // Don't care about name here.
+    buildCache
+  );
+}
+
+// ../zero-schema/src/normalized-schema.ts
+function normalizeSchema(schema) {
+  if (schema instanceof NormalizedSchema) {
+    return schema;
+  }
+  return new NormalizedSchema(schema);
+}
+var NormalizedSchema = class {
+  version;
+  tables;
+  constructor(schema) {
+    this.version = schema.version;
+    this.tables = normalizeTables(schema.tables);
+  }
+};
+function normalizeTables(tables) {
+  const rv = {};
+  const tableSchemaCache = /* @__PURE__ */ new Map();
+  for (const [name, table] of sortedEntries(tables)) {
+    rv[name] = normalizeTableSchemaWithCache(table, name, tableSchemaCache);
   }
+  return rv;
 }
 
 // ../zql/src/query/query-impl.ts
@@ -9395,7 +9463,12 @@ var primitiveSchema = valita_exports.union(
   valita_exports.boolean(),
   valita_exports.null()
 );
-var equalityOpsSchema = valita_exports.union(valita_exports.literal("="), valita_exports.literal("!="));
+var equalityOpsSchema = valita_exports.union(
+  valita_exports.literal("="),
+  valita_exports.literal("!="),
+  valita_exports.literal("IS"),
+  valita_exports.literal("IS NOT")
+);
 var orderOpsSchema = valita_exports.union(
   valita_exports.literal("<"),
   valita_exports.literal(">"),
@@ -9423,6 +9496,7 @@ var simpleConditionSchema = valita_exports.object({
     valita_exports.string(),
     valita_exports.number(),
     valita_exports.boolean(),
+    valita_exports.null(),
     readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean())),
     valita_exports.object({
       type: valita_exports.literal("static"),
@@ -9431,10 +9505,20 @@ var simpleConditionSchema = valita_exports.object({
     })
   )
 });
+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),
+  op: correlatedSubqueryConditionOperatorSchema
+});
 var conditionSchema = valita_exports.union(
   simpleConditionSchema,
   valita_exports.lazy(() => conjunctionSchema),
-  valita_exports.lazy(() => disjunctionSchema)
+  valita_exports.lazy(() => disjunctionSchema),
+  correlatedSubqueryConditionSchema
 );
 var conjunctionSchema = readonlyObject({
   type: valita_exports.literal("and"),
@@ -9501,7 +9585,7 @@ function normalizeAST(ast) {
   return normalized;
 }
 function sortedWhere(where) {
-  if (where.type === "simple") {
+  if (where.type === "simple" || where.type === "correlatedSubquery") {
     return where;
   }
   return {
@@ -9525,6 +9609,15 @@ function cmpCondition(a, b) {
   if (b.type === "simple") {
     return 1;
   }
+  if (a.type === "correlatedSubquery") {
+    if (b.type !== "correlatedSubquery") {
+      return -1;
+    }
+    return cmpRelated(a.related, b.related) || compareUTF8MaybeNull(a.op, b.op);
+  }
+  if (b.type === "correlatedSubquery") {
+    return -1;
+  }
   const val = compareUTF8MaybeNull(a.type, b.type);
   if (val !== 0) {
     return val;
@@ -9544,7 +9637,7 @@ function flattened(cond) {
   if (cond === void 0) {
     return void 0;
   }
-  if (cond.type === "simple") {
+  if (cond.type === "simple" || cond.type === "correlatedSubquery") {
     return cond;
   }
   const conditions = defined(
@@ -9590,31 +9683,275 @@ function hashOfAST(ast) {
   return hash;
 }
 
-// ../zql/src/ivm/fan-in.ts
-var FanIn = class {
-  #inputs;
-  #fanOut;
-  #output;
-  #schema;
-  constructor(fanOut, inputs) {
-    this.#inputs = inputs;
-    this.#schema = inputs[0].getSchema();
-    this.#fanOut = fanOut;
-    for (const input of inputs) {
-      input.setOutput(this);
-      assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);
-    }
+// ../zql/src/ivm/change.ts
+function rowForChange(change) {
+  const { type } = change;
+  return type === "add" || type === "remove" ? change.node.row : change.row;
+}
+
+// ../zql/src/ivm/data.ts
+import { compareUTF8 as compareUTF84 } from "compare-utf8";
+function compareValues(a, b) {
+  a = normalizeUndefined(a);
+  b = normalizeUndefined(b);
+  if (a === b) {
+    return 0;
   }
-  setOutput(output) {
-    this.#output = output;
+  if (a === null) {
+    return -1;
   }
-  destroy() {
-    for (const input of this.#inputs) {
-      input.destroy();
-    }
+  if (b === null) {
+    return 1;
   }
-  getSchema() {
-    return this.#inputs[0].getSchema();
+  if (typeof a === "boolean") {
+    assertBoolean(b);
+    return a ? 1 : -1;
+  }
+  if (typeof a === "number") {
+    assertNumber(b);
+    return a - b;
+  }
+  if (typeof a === "string") {
+    assertString(b);
+    return compareUTF84(a, b);
+  }
+  throw new Error(`Unsupported type: ${a}`);
+}
+function normalizeUndefined(v2) {
+  return v2 ?? null;
+}
+function makeComparator(order) {
+  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;
+      }
+    }
+    return 0;
+  };
+}
+function valuesEqual(a, b) {
+  a = normalizeUndefined(a);
+  b = normalizeUndefined(b);
+  if (a === null || b === null) {
+    return false;
+  }
+  return a === b;
+}
+
+// ../zql/src/ivm/stream.ts
+function* take(stream, limit) {
+  if (limit < 1) {
+    return;
+  }
+  let count = 0;
+  for (const v2 of stream) {
+    yield v2;
+    if (++count === limit) {
+      break;
+    }
+  }
+}
+function first(stream) {
+  const it = stream[Symbol.iterator]();
+  const { value } = it.next();
+  it.return?.();
+  return value;
+}
+
+// ../zql/src/ivm/exists.ts
+var Exists = class {
+  #input;
+  #relationshipName;
+  #storage;
+  #not;
+  #output;
+  constructor(input, storage, relationshipName, type) {
+    this.#input = input;
+    this.#relationshipName = relationshipName;
+    this.#input.setOutput(this);
+    this.#storage = storage;
+    assert(this.#input.getSchema().relationships[relationshipName]);
+    this.#not = type === "NOT EXISTS";
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  *fetch(req) {
+    for (const node of this.#input.fetch(req)) {
+      if (this.#filter(node.row)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#filter(node.row)) {
+        yield node;
+      }
+      this.#delSize(node.row);
+    }
+  }
+  push(change) {
+    assert(this.#output, "Output not set");
+    switch (change.type) {
+      case "add":
+      case "edit": {
+        this.#pushWithFilter(change);
+        return;
+      }
+      case "remove": {
+        this.#pushWithFilter(change);
+        this.#delSize(change.node.row);
+        return;
+      }
+      case "child":
+        if (change.child.relationshipName !== this.#relationshipName || change.child.change.type === "edit" || change.child.change.type === "child") {
+          this.#pushWithFilter(change);
+          return;
+        }
+        switch (change.child.change.type) {
+          case "add": {
+            let size = this.#getSize(change.row);
+            if (size !== void 0) {
+              size++;
+              this.#setSize(change.row, size);
+            } else {
+              size = this.#fetchSize(change.row);
+            }
+            if (size === 1) {
+              this.#output.push({
+                type: this.#not ? "remove" : "add",
+                node: this.#fetchNodeForRow(change.row)
+              });
+            } else {
+              this.#pushWithFilter(change, size);
+            }
+            return;
+          }
+          case "remove": {
+            let size = this.#getSize(change.row);
+            if (size !== void 0) {
+              assert(size > 0);
+              size--;
+              this.#setSize(change.row, size);
+            } else {
+              size = this.#fetchSize(change.row);
+            }
+            if (size === 0) {
+              this.#output.push({
+                type: this.#not ? "add" : "remove",
+                node: this.#fetchNodeForRow(change.row)
+              });
+            } else {
+              this.#pushWithFilter(change, size);
+            }
+            return;
+          }
+        }
+        return;
+      default:
+        unreachable(change);
+    }
+  }
+  /**
+   * Returns whether or not the change's row's this.#relationshipName
+   * relationship passes the exist/not exists filter condition.
+   * If the optional `size` is passed it is used.
+   * Otherwise, if there is a stored size for the row it is used.
+   * Otherwise the size is computed by fetching a node for the row from
+   * this.#input (this computed size is also stored).
+   */
+  #filter(row, size) {
+    const exists = (size ?? this.#getOrFetchSize(row)) > 0;
+    return this.#not ? !exists : exists;
+  }
+  /**
+   * Pushes a change if this.#filter is true for its row.
+   */
+  #pushWithFilter(change, size) {
+    const row = rowForChange(change);
+    if (this.#filter(row, size)) {
+      must(this.#output).push(change);
+    }
+  }
+  #getSize(row) {
+    return this.#storage.get(this.#makeSizeStorageKey(row));
+  }
+  #setSize(row, size) {
+    this.#storage.set(this.#makeSizeStorageKey(row), size);
+  }
+  #delSize(row) {
+    this.#storage.del(this.#makeSizeStorageKey(row));
+  }
+  #getOrFetchSize(row) {
+    const size = this.#getSize(row);
+    if (size !== void 0) {
+      return size;
+    }
+    return this.#fetchSize(row);
+  }
+  #fetchSize(row) {
+    const relationship = this.#fetchNodeForRow(row).relationships[this.#relationshipName];
+    assert(relationship);
+    let size = 0;
+    for (const _relatedNode of relationship) {
+      size++;
+    }
+    this.#setSize(row, size);
+    return size;
+  }
+  #fetchNodeForRow(row) {
+    return must(
+      first(
+        this.#input.fetch({
+          start: { row, basis: "at" }
+        })
+      )
+    );
+  }
+  #makeSizeStorageKey(row) {
+    const primaryKey = [];
+    for (const key of this.#input.getSchema().primaryKey) {
+      primaryKey.push(normalizeUndefined(row[key]));
+    }
+    return JSON.stringify(["size", primaryKey]);
+  }
+};
+
+// ../zql/src/ivm/fan-in.ts
+var FanIn = class {
+  #inputs;
+  #fanOut;
+  #schema;
+  #output;
+  constructor(fanOut, inputs) {
+    this.#inputs = inputs;
+    this.#schema = fanOut.getSchema();
+    this.#fanOut = fanOut;
+    for (const input of inputs) {
+      input.setOutput(this);
+      assert(this.#schema === input.getSchema(), `Schema mismatch in fan-in`);
+    }
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    for (const input of this.#inputs) {
+      input.destroy();
+    }
+  }
+  getSchema() {
+    return this.#schema;
   }
   fetch(req) {
     return this.#fetchOrCleanup((input) => input.fetch(req));
@@ -9639,19 +9976,16 @@ var FanIn = class {
 // ../zql/src/ivm/fan-out.ts
 var FanOut = class {
   #input;
-  #outputs;
+  #outputs = [];
   // FanOut is paired with a FanIn.
   // Once FanIn has received a push from FanOut along
   // any branch, FanOut no longer needs to push that value
   // across the rest of its outputs..
-  #fanInReceivedPush;
-  #destroyCount;
+  #fanInReceivedPush = false;
+  #destroyCount = 0;
   constructor(input) {
     this.#input = input;
-    this.#input.setOutput(this);
-    this.#outputs = [];
-    this.#fanInReceivedPush = false;
-    this.#destroyCount = 0;
+    input.setOutput(this);
   }
   setOutput(output) {
     this.#outputs.push(output);
@@ -9724,7 +10058,7 @@ var Filter = class {
     this.#input = input;
     this.#mode = mode;
     this.#predicate = predicate;
-    this.#input.setOutput(this);
+    input.setOutput(this);
   }
   setOutput(output) {
     this.#output = output;
@@ -9771,78 +10105,6 @@ var Filter = class {
   }
 };
 
-// ../zql/src/ivm/data.ts
-import { compareUTF8 as compareUTF84 } from "compare-utf8";
-function compareValues(a, b) {
-  a = normalizeUndefined(a);
-  b = normalizeUndefined(b);
-  if (a === b) {
-    return 0;
-  }
-  if (a === null) {
-    return -1;
-  }
-  if (b === null) {
-    return 1;
-  }
-  if (typeof a === "boolean") {
-    assertBoolean(b);
-    return a ? 1 : -1;
-  }
-  if (typeof a === "number") {
-    assertNumber(b);
-    return a - b;
-  }
-  if (typeof a === "string") {
-    assertString(b);
-    return compareUTF84(a, b);
-  }
-  throw new Error(`Unsupported type: ${a}`);
-}
-function normalizeUndefined(v2) {
-  return v2 ?? null;
-}
-function makeComparator(order) {
-  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;
-      }
-    }
-    return 0;
-  };
-}
-function valuesEqual(a, b) {
-  a = normalizeUndefined(a);
-  b = normalizeUndefined(b);
-  if (a === null || b === null) {
-    return false;
-  }
-  return a === b;
-}
-
-// ../zql/src/ivm/stream.ts
-function* take(stream, limit) {
-  if (limit < 1) {
-    return;
-  }
-  let count = 0;
-  for (const v2 of stream) {
-    yield v2;
-    if (++count === limit) {
-      break;
-    }
-  }
-}
-function first(stream) {
-  const it = stream[Symbol.iterator]();
-  const { value } = it.next();
-  it.return?.();
-  return value;
-}
-
 // ../zql/src/ivm/join.ts
 var Join = class {
   #parent;
@@ -10139,7 +10401,7 @@ var Skip = class {
     this.#input = input;
     this.#bound = bound;
     this.#comparator = input.getSchema().compareRows;
-    this.#input.setOutput(this);
+    input.setOutput(this);
   }
   getSchema() {
     return this.#input.getSchema();
@@ -10230,10 +10492,10 @@ var Take = class {
     this.#partitionKey = partitionKey;
     assert(limit >= 0);
     assertOrderingIncludesPK(
-      this.#input.getSchema().sort,
-      this.#input.getSchema().primaryKey
+      input.getSchema().sort,
+      input.getSchema().primaryKey
     );
-    this.#input.setOutput(this);
+    input.setOutput(this);
   }
   setOutput(output) {
     this.#output = output;
@@ -10355,8 +10617,7 @@ var Take = class {
       return;
     }
     assert(this.#output, "Output not set");
-    assert(change.type !== "child", "child changes are not supported");
-    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.node.row);
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(rowForChange(change));
     if (!takeState) {
       return;
     }
@@ -10475,6 +10736,10 @@ var Take = class {
         maxBound
       );
       this.#output.push(change);
+    } else if (change.type === "child") {
+      if (takeState.bound && compareRows(change.row, takeState.bound) <= 0) {
+        this.#output.push(change);
+      }
     }
   }
   #pushEditChange(change) {
@@ -10722,10 +10987,17 @@ function patternToRegExp(source, flags = "") {
 
 // ../zql/src/builder/filter.ts
 function createPredicate(condition) {
-  const impl = createPredicateImpl(
-    condition.value,
-    condition.op
-  );
+  switch (condition.op) {
+    case "IS":
+    case "IS NOT": {
+      const impl2 = createIsPredicate(condition.value, condition.op);
+      return (row) => impl2(row[condition.field]);
+    }
+  }
+  if (condition.value === null || condition.value === void 0) {
+    return (_row) => false;
+  }
+  const impl = createPredicateImpl(condition.value, condition.op);
   return (row) => {
     const lhs = row[condition.field];
     if (lhs === null || lhs === void 0) {
@@ -10734,6 +11006,14 @@ function createPredicate(condition) {
     return impl(lhs);
   };
 }
+function createIsPredicate(rhs, operator) {
+  switch (operator) {
+    case "IS":
+      return (lhs) => lhs === rhs;
+    case "IS NOT":
+      return (lhs) => lhs !== rhs;
+  }
+}
 function createPredicateImpl(rhs, operator) {
   switch (operator) {
     case "=":
@@ -10751,11 +11031,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not2(getLikePredicate(rhs, ""));
+      return not(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not2(getLikePredicate(rhs, "i"));
+      return not(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -10771,7 +11051,7 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not2(f) {
+function not(f) {
   return (lhs) => !f(lhs);
 }
 
@@ -10798,10 +11078,22 @@ function bindStaticParameters(ast, staticQueryParameters) {
     return node;
   };
   function bindCondition(condition) {
-    return condition.type === "simple" ? {
-      ...condition,
-      value: bindValue(condition.value)
-    } : {
+    if (condition.type === "simple") {
+      return {
+        ...condition,
+        value: bindValue(condition.value)
+      };
+    }
+    if (condition.type === "correlatedSubquery") {
+      return {
+        ...condition,
+        related: {
+          ...condition.related,
+          subquery: visit(condition.related.subquery)
+        }
+      };
+    }
+    return {
       ...condition,
       conditions: condition.conditions.map(bindCondition)
     };
@@ -10834,60 +11126,49 @@ function buildPipelineInternal(ast, delegate, staticQueryParameters, partitionKe
   const conn = source.connect(must(ast.orderBy), ast.where);
   let end = conn;
   const { appliedFilters } = conn;
+  ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
   if (ast.start) {
     end = new Skip(end, ast.start);
   }
+  for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
+    end = applyCorrelatedSubQuery(csq, delegate, staticQueryParameters, end);
+  }
   if (ast.where) {
-    end = applyWhere(end, ast.where, appliedFilters);
+    end = applyWhere(end, ast.where, appliedFilters, delegate);
   }
   if (ast.limit) {
     end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
   }
   if (ast.related) {
-    for (const sq of ast.related) {
-      assert(sq.subquery.alias, "Subquery must have an alias");
-      const child = buildPipelineInternal(
-        sq.subquery,
-        delegate,
-        staticQueryParameters,
-        sq.correlation.childField
-      );
-      end = new Join({
-        parent: end,
-        child,
-        storage: delegate.createStorage(),
-        parentKey: sq.correlation.parentField,
-        childKey: sq.correlation.childField,
-        relationshipName: sq.subquery.alias,
-        hidden: sq.hidden ?? false
-      });
+    for (const csq of ast.related) {
+      end = applyCorrelatedSubQuery(csq, delegate, staticQueryParameters, end);
     }
   }
   return end;
 }
-function applyWhere(input, condition, appliedFilters) {
+function applyWhere(input, condition, appliedFilters, delegate) {
   switch (condition.type) {
     case "and":
-      return applyAnd(input, condition, appliedFilters);
+      return applyAnd(input, condition, appliedFilters, delegate);
     case "or":
-      return applyOr(input, condition, appliedFilters);
+      return applyOr(input, condition, appliedFilters, delegate);
+    case "correlatedSubquery":
+      return applyCorrelatedSubqueryCondition(input, condition, delegate);
     default:
       return applySimpleCondition(input, condition, appliedFilters);
   }
 }
-function applyAnd(input, condition, appliedFilters) {
+function applyAnd(input, condition, appliedFilters, delegate) {
   for (const subCondition of condition.conditions) {
-    input = applyWhere(input, subCondition, appliedFilters);
+    input = applyWhere(input, subCondition, appliedFilters, delegate);
   }
   return input;
 }
-function applyOr(input, condition, appliedFilters) {
+function applyOr(input, condition, appliedFilters, delegate) {
   const fanOut = new FanOut(input);
-  const branches = [];
-  for (const subCondition of condition.conditions) {
-    branches.push(applyWhere(fanOut, subCondition, appliedFilters));
-  }
-  assert(branches.length > 0, "Or condition must have at least one branch");
+  const branches = condition.conditions.map(
+    (subCondition) => applyWhere(fanOut, subCondition, appliedFilters, delegate)
+  );
   return new FanIn(fanOut, branches);
 }
 function applySimpleCondition(input, condition, appliedFilters) {
@@ -10897,6 +11178,58 @@ function applySimpleCondition(input, condition, appliedFilters) {
     createPredicate(condition)
   );
 }
+function applyCorrelatedSubQuery(sq, delegate, staticQueryParameters, end) {
+  assert(sq.subquery.alias, "Subquery must have an alias");
+  const child = buildPipelineInternal(
+    sq.subquery,
+    delegate,
+    staticQueryParameters,
+    sq.correlation.childField
+  );
+  end = new Join({
+    parent: end,
+    child,
+    storage: delegate.createStorage(),
+    parentKey: sq.correlation.parentField,
+    childKey: sq.correlation.childField,
+    relationshipName: sq.subquery.alias,
+    hidden: sq.hidden ?? false
+  });
+  return end;
+}
+function applyCorrelatedSubqueryCondition(input, condition, delegate) {
+  assert(condition.op === "EXISTS" || condition.op === "NOT EXISTS");
+  return new Exists(
+    input,
+    delegate.createStorage(),
+    must(condition.related.subquery.alias),
+    condition.op
+  );
+}
+function gatherCorrelatedSubqueryQueriesFromCondition(condition) {
+  const csqs = [];
+  const gather = (condition2) => {
+    if (condition2.type === "correlatedSubquery") {
+      assert(condition2.op === "EXISTS" || condition2.op === "NOT EXISTS");
+      csqs.push({
+        ...condition2.related,
+        subquery: { ...condition2.related.subquery, limit: EXISTS_LIMIT }
+      });
+      return;
+    }
+    if (condition2.type === "and" || condition2.type === "or") {
+      for (const c of condition2.conditions) {
+        gather(c);
+      }
+      return;
+    }
+  };
+  if (condition) {
+    gather(condition);
+  }
+  return csqs;
+}
+var EXISTS_LIMIT = 5;
 function assertOrderingIncludesPK(ordering, pk) {
   const orderingFields = ordering.map(([field]) => field);
   const missingFields = pk.filter((pkField) => !orderingFields.includes(pkField));
@@ -10912,6 +11245,63 @@ function assertOrderingIncludesPK(ordering, pk) {
     );
   }
 }
+function uniquifyCorrelatedSubqueryConditionAliases(ast) {
+  if (!ast.where) {
+    return ast;
+  }
+  const { where } = ast;
+  if (where.type !== "and" && where.type !== "or") {
+    return ast;
+  }
+  let count = 0;
+  const uniquifyCorrelatedSubquery = (csqc) => ({
+    ...csqc,
+    related: {
+      ...csqc.related,
+      subquery: {
+        ...csqc.related.subquery,
+        alias: (csqc.related.subquery.alias ?? "") + "_" + count++
+      }
+    }
+  });
+  const uniquifyAnd = (and2) => {
+    const conds2 = [];
+    for (const cond of and2.conditions) {
+      if (cond.type === "correlatedSubquery") {
+        conds2.push(uniquifyCorrelatedSubquery(cond));
+      } else {
+        conds2.push(cond);
+      }
+    }
+    return {
+      ...and2,
+      conditions: conds2
+    };
+  };
+  if (where.type === "and") {
+    return {
+      ...ast,
+      where: uniquifyAnd(where)
+    };
+  }
+  const conds = [];
+  for (const cond of where.conditions) {
+    if (cond.type === "simple") {
+      conds.push(cond);
+    } else if (cond.type === "correlatedSubquery") {
+      conds.push(uniquifyCorrelatedSubquery(cond));
+    } else if (cond.type === "and") {
+      conds.push(uniquifyAnd(cond));
+    }
+  }
+  return {
+    ...ast,
+    where: {
+      ...where,
+      conditions: conds
+    }
+  };
+}
 
 // ../zql/src/ivm/array-view.ts
 var ArrayView = class {
@@ -10928,8 +11318,8 @@ var ArrayView = class {
     this.#input = input;
     this.#schema = input.getSchema();
     this.#format = format;
-    this.#input.setOutput(this);
     this.#root = { "": format.singular ? void 0 : [] };
+    input.setOutput(this);
     this.#hydrate();
   }
   get data() {
@@ -10977,159 +11367,198 @@ var ArrayView = class {
   }
 };
 
-// ../shared/src/sorted-entries.ts
-function sortedEntries(object16) {
-  return Object.entries(object16).sort((a, b) => stringCompare(a[0], b[0]));
-}
-
-// ../zero-schema/src/table-schema.ts
-function isFieldRelationship(relationship) {
-  return relationship.junction === void 0;
-}
-function isJunctionRelationship(relationship) {
-  return !isFieldRelationship(relationship);
-}
-
-// ../zero-schema/src/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
-    );
+// ../zql/src/query/expression.ts
+var ExpressionBuilder = class {
+  #exists;
+  constructor(exists) {
+    this.#exists = exists;
+    this.exists = this.exists.bind(this);
+  }
+  get eb() {
+    return this;
+  }
+  cmp(field, opOrValue, value) {
+    return cmp(field, opOrValue, value);
+  }
+  and = and;
+  or = or;
+  not = not2;
+  exists(relationship, cb) {
+    return this.#exists(relationship, cb);
   }
 };
-function normalizeTableSchema(tableSchema) {
-  return normalizeTableSchemaWithCache(
-    tableSchema,
-    tableSchema.tableName,
-    /* @__PURE__ */ new Map()
-  );
-}
-function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCache) {
-  if (tableSchema instanceof NormalizedTableSchema) {
-    return tableSchema;
+function and(...conditions) {
+  const expressions = filterTrue(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
   }
-  assert(
-    tableSchema.tableName === expectedName,
-    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedName}"`
-  );
-  let normalizedTableSchema = tableSchemaCache.get(tableSchema);
-  if (normalizedTableSchema) {
-    return normalizedTableSchema;
+  if (expressions.some(isAlwaysFalse)) {
+    return FALSE;
   }
-  normalizedTableSchema = new NormalizedTableSchema(
-    tableSchema,
-    tableSchemaCache
-  );
-  return normalizedTableSchema;
+  return { type: "and", conditions: expressions };
 }
-function isSorted(arr) {
-  for (let i = 1; i < arr.length; i++) {
-    if (arr[i - 1] >= arr[i]) {
-      return false;
-    }
+function or(...conditions) {
+  const expressions = filterFalse(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
   }
-  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");
+  if (expressions.some(isAlwaysTrue)) {
+    return TRUE;
   }
+  return { type: "or", conditions: expressions };
 }
-function normalizePrimaryKey(arr) {
-  if (isSorted(arr)) {
-    return arr;
+function not2(expression) {
+  switch (expression.type) {
+    case "and":
+      return {
+        type: "or",
+        conditions: expression.conditions.map(not2)
+      };
+    case "or":
+      return {
+        type: "and",
+        conditions: expression.conditions.map(not2)
+      };
+    case "correlatedSubquery":
+      return {
+        type: "correlatedSubquery",
+        related: expression.related,
+        op: negateOperator(expression.op)
+      };
+    default:
+      return {
+        type: "simple",
+        op: negateOperator(expression.op),
+        field: expression.field,
+        value: expression.value
+      };
   }
-  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);
+function cmp(field, opOrValue, value) {
+  let op;
+  if (value === void 0) {
+    value = opOrValue;
+    op = "=";
+  } else {
+    op = opOrValue;
   }
-  return rv;
-}
-function normalizeSchemaValue(value) {
   return {
-    type: value.type,
-    optional: value.optional ?? false
+    type: "simple",
+    field,
+    op,
+    value
   };
 }
-function normalizeRelationships(relationships, tableSchemaCache) {
-  const rv = {};
-  for (const [name, relationship] of sortedEntries(relationships)) {
-    rv[name] = normalizeRelationship(relationship, tableSchemaCache);
-  }
-  return rv;
+var TRUE = {
+  type: "and",
+  conditions: []
+};
+var FALSE = {
+  type: "or",
+  conditions: []
+};
+function isAlwaysTrue(condition) {
+  return condition.type === "and" && condition.conditions.length === 0;
 }
-function normalizeRelationship(relationship, tableSchemaCache) {
-  if (isFieldRelationship(relationship)) {
-    return normalizeFieldRelationship(relationship, tableSchemaCache);
-  }
-  return normalizeJunctionRelationship(relationship, tableSchemaCache);
+function isAlwaysFalse(condition) {
+  return condition.type === "or" && condition.conditions.length === 0;
 }
-function normalizeFieldRelationship(relationship, tableSchemaCache) {
-  return {
-    source: relationship.source,
-    dest: {
-      field: relationship.dest.field,
-      schema: normalizeLazyTableSchema(
-        relationship.dest.schema,
-        tableSchemaCache
-      )
+function flatten(type, conditions) {
+  const flattened2 = [];
+  for (const c of conditions) {
+    if (c.type === type) {
+      flattened2.push(...c.conditions);
+    } else {
+      flattened2.push(c);
     }
-  };
+  }
+  return flattened2;
+}
+var negateSimpleOperatorMap = {
+  ["="]: "!=",
+  ["!="]: "=",
+  ["<"]: ">=",
+  [">"]: "<=",
+  [">="]: "<",
+  ["<="]: ">",
+  ["IN"]: "NOT IN",
+  ["NOT IN"]: "IN",
+  ["LIKE"]: "NOT LIKE",
+  ["NOT LIKE"]: "LIKE",
+  ["ILIKE"]: "NOT ILIKE",
+  ["NOT ILIKE"]: "ILIKE",
+  ["IS"]: "IS NOT",
+  ["IS NOT"]: "IS"
+};
+var negateOperatorMap = {
+  ...negateSimpleOperatorMap,
+  ["EXISTS"]: "NOT EXISTS",
+  ["NOT EXISTS"]: "EXISTS"
+};
+function negateOperator(op) {
+  return must(negateOperatorMap[op]);
 }
-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 filterUndefined(array9) {
+  return array9.filter((e) => e !== void 0);
+}
+function filterTrue(conditions) {
+  return conditions.filter((c) => !isAlwaysTrue(c));
+}
+function filterFalse(conditions) {
+  return conditions.filter((c) => !isAlwaysFalse(c));
+}
+
+// ../zql/src/query/dnf.ts
+function dnf(condition) {
+  return unwrap(dnfInner(condition));
+}
+function dnfInner(condition) {
+  switch (condition.type) {
+    case "simple":
+    case "correlatedSubquery":
+      return { type: "or", conditions: [condition] };
+    case "and":
+      return distributeAnd(condition.conditions.map(dnfInner));
+    case "or":
+      return {
+        type: "or",
+        conditions: flatten(
+          "or",
+          condition.conditions.map(dnfInner).flatMap((c) => c.conditions)
+        )
+      };
+    default:
+      unreachable(condition);
+  }
+}
+function distributeAnd(conditions) {
+  if (conditions.length === 0) {
+    return { type: "or", conditions: [TRUE] };
+  }
+  return conditions.reduce((acc, orCondition) => {
+    const newConditions = [];
+    for (const accCondition of acc.conditions) {
+      for (const orSubCondition of orCondition.conditions) {
+        newConditions.push({
+          type: "and",
+          conditions: [accCondition, orSubCondition]
+        });
+      }
     }
-  };
+    return {
+      type: "or",
+      conditions: flatten("or", newConditions)
+    };
+  });
 }
-function normalizeLazyTableSchema(tableSchema, buildCache) {
-  const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
-  return normalizeTableSchemaWithCache(
-    tableSchemaInstance,
-    tableSchemaInstance.tableName,
-    // Don't care about name here.
-    buildCache
-  );
+function unwrap(c) {
+  if (c.type === "simple" || c.type === "correlatedSubquery") {
+    return c;
+  }
+  if (c.conditions.length === 1) {
+    return unwrap(c.conditions[0]);
+  }
+  return { type: c.type, conditions: flatten(c.type, c.conditions.map(unwrap)) };
 }
 
 // ../zql/src/query/query-impl.ts
@@ -11139,6 +11568,14 @@ function newQuery(delegate, tableSchema) {
 function newQueryWithDetails(delegate, schema, ast, format) {
   return new QueryImpl(delegate, schema, ast, format);
 }
+function staticParam(anchorClass, field) {
+  return {
+    type: "static",
+    anchor: anchorClass,
+    field
+  };
+}
+var SUBQ_PREFIX = "zsubq_";
 var AbstractQuery = class {
   #ast;
   #schema;
@@ -11160,9 +11597,6 @@ var AbstractQuery = class {
     }
     return this.#hash;
   }
-  select(..._fields) {
-    return this._newQuery(this.#schema, this.#ast, this.#format);
-  }
   one() {
     return this._newQuery(
       this.#schema,
@@ -11176,13 +11610,21 @@ var AbstractQuery = class {
       }
     );
   }
+  whereExists(relationship, cb = (q) => q) {
+    return this.where(({ exists }) => exists(relationship, cb));
+  }
   related(relationship, cb = (q) => q) {
+    if (relationship.startsWith(SUBQ_PREFIX)) {
+      throw new Error(
+        `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
+      );
+    }
     const related = this.#schema.relationships[relationship];
     assert(related, "Invalid relationship");
-    const related1 = related;
-    const related2 = related;
-    if (isFieldRelationship(related1)) {
-      const destSchema = related1.dest.schema;
+    const fieldRelationship = related;
+    const junctionRelationship = related;
+    if (isFieldRelationship(fieldRelationship)) {
+      const destSchema = fieldRelationship.dest.schema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11201,8 +11643,8 @@ var AbstractQuery = class {
             ...this.#ast.related ?? [],
             {
               correlation: {
-                parentField: related1.source,
-                childField: related1.dest.field,
+                parentField: fieldRelationship.source,
+                childField: fieldRelationship.dest.field,
                 op: "="
               },
               subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
@@ -11218,9 +11660,9 @@ var AbstractQuery = class {
         }
       );
     }
-    if (isJunctionRelationship(related2)) {
-      const destSchema = related2.dest.schema;
-      const junctionSchema = related2.junction.schema;
+    if (isJunctionRelationship(junctionRelationship)) {
+      const destSchema = junctionRelationship.dest.schema;
+      const junctionSchema = junctionRelationship.junction.schema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11239,8 +11681,8 @@ var AbstractQuery = class {
             ...this.#ast.related ?? [],
             {
               correlation: {
-                parentField: related2.source,
-                childField: related2.junction.sourceField,
+                parentField: junctionRelationship.source,
+                childField: junctionRelationship.junction.sourceField,
                 op: "="
               },
               subquery: {
@@ -11250,8 +11692,8 @@ var AbstractQuery = class {
                 related: [
                   {
                     correlation: {
-                      parentField: related2.junction.destField,
-                      childField: related2.dest.field,
+                      parentField: junctionRelationship.junction.destField,
+                      childField: junctionRelationship.dest.field,
                       op: "="
                     },
                     hidden: true,
@@ -11273,13 +11715,13 @@ var AbstractQuery = class {
     }
     throw new Error(`Invalid relationship ${relationship}`);
   }
-  where(field, opOrValue, value) {
+  where(fieldOrExpressionFactory, opOrValue, value) {
     let cond;
-    if (opOrValue === void 0 && value === void 0) {
-      assert(typeof field !== "string", `Invalid condition: ${field}`);
-      cond = field;
+    if (typeof fieldOrExpressionFactory === "function") {
+      cond = fieldOrExpressionFactory(new ExpressionBuilder(this.#exists));
     } else {
-      cond = cmp(field, opOrValue, value);
+      assert(opOrValue !== void 0, "Invalid condition");
+      cond = cmp(fieldOrExpressionFactory, opOrValue, value);
     }
     const existingWhere = this.#ast.where;
     if (existingWhere) {
@@ -11289,7 +11731,7 @@ var AbstractQuery = class {
       this.#schema,
       {
         ...this.#ast,
-        where: cond
+        where: dnf(cond)
       },
       this.#format
     );
@@ -11333,6 +11775,80 @@ var AbstractQuery = class {
       this.#format
     );
   }
+  #exists = (relationship, cb = (q) => q) => {
+    const related = this.#schema.relationships[relationship];
+    assert(related, "Invalid relationship");
+    const fieldRelationship = related;
+    const junctionRelationship = related;
+    if (isFieldRelationship(fieldRelationship)) {
+      const destSchema = fieldRelationship.dest.schema;
+      const sq = cb(
+        this._newQuery(
+          destSchema,
+          {
+            table: destSchema.tableName,
+            alias: `${SUBQ_PREFIX}${relationship}`
+          },
+          void 0
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          correlation: {
+            parentField: fieldRelationship.source,
+            childField: fieldRelationship.dest.field,
+            op: "="
+          },
+          subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
+        },
+        op: "EXISTS"
+      };
+    }
+    if (isJunctionRelationship(junctionRelationship)) {
+      const destSchema = junctionRelationship.dest.schema;
+      const junctionSchema = junctionRelationship.junction.schema;
+      const queryToDest = cb(
+        this._newQuery(
+          destSchema,
+          {
+            table: destSchema.tableName,
+            alias: `${SUBQ_PREFIX}${relationship}`
+          },
+          void 0
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          correlation: {
+            parentField: junctionRelationship.source,
+            childField: junctionRelationship.junction.sourceField,
+            op: "="
+          },
+          subquery: {
+            table: junctionSchema.tableName,
+            alias: `${SUBQ_PREFIX}${relationship}`,
+            orderBy: addPrimaryKeys(junctionSchema, void 0),
+            where: {
+              type: "correlatedSubquery",
+              related: {
+                correlation: {
+                  parentField: junctionRelationship.junction.destField,
+                  childField: junctionRelationship.dest.field,
+                  op: "="
+                },
+                subquery: addPrimaryKeysToAst(destSchema, queryToDest.#ast)
+              },
+              op: "EXISTS"
+            }
+          }
+        },
+        op: "EXISTS"
+      };
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
   #completedAST;
   _completeAst() {
     if (!this.#completedAST) {
@@ -11444,6 +11960,113 @@ function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit)
   return v2;
 }
 
+// ../zql/src/query/auth-query.ts
+var AuthQuery = class _AuthQuery extends AbstractQuery {
+  constructor(schema, ast = { table: schema.tableName }, format) {
+    super(schema, ast, format);
+  }
+  _newQuery(schema, ast, format) {
+    return new _AuthQuery(schema, ast, format);
+  }
+  get ast() {
+    return this._completeAst();
+  }
+  materialize() {
+    throw new Error("AuthQuery cannot be materialized");
+  }
+  run() {
+    throw new Error("AuthQuery cannot be run");
+  }
+  preload() {
+    throw new Error("AuthQuery cannot be preloaded");
+  }
+};
+
+// ../zero-schema/src/authorization.ts
+async function defineAuthorization(schema, definer) {
+  const normalizedSchema = normalizeSchema(schema);
+  const queries = {};
+  for (const [name, tableSchema] of Object.entries(normalizedSchema.tables)) {
+    queries[name] = new AuthQuery(tableSchema);
+  }
+  const config = await definer(queries);
+  return compileAuthorization(config);
+}
+function compileAuthorization(authz) {
+  if (!authz) {
+    return void 0;
+  }
+  const ret = {};
+  for (const [tableName, tableConfig] of Object.entries(authz)) {
+    ret[tableName] = {
+      row: compileRowConfig(tableConfig.row),
+      cell: compileCellConfig(tableConfig.cell)
+    };
+  }
+  return ret;
+}
+function compileRowConfig(rowRules) {
+  if (!rowRules) {
+    return void 0;
+  }
+  return {
+    select: compileInstanceRules(rowRules.select),
+    insert: compileInstanceRules(rowRules.insert),
+    update: compileInstanceRules(rowRules.update),
+    delete: compileInstanceRules(rowRules.delete)
+  };
+}
+function compileInstanceRules(rules) {
+  if (!rules) {
+    return void 0;
+  }
+  return rules.map(
+    (rule) => [
+      "allow",
+      rule(
+        authDataRef,
+        preMutationRowRef
+      ).ast
+    ]
+  );
+}
+function compileCellConfig(cellRules) {
+  if (!cellRules) {
+    return void 0;
+  }
+  const ret = {};
+  for (const [columnName, rules] of Object.entries(cellRules)) {
+    ret[columnName] = {
+      select: compileInstanceRules(rules.select),
+      insert: compileInstanceRules(rules.insert),
+      update: compileInstanceRules(rules.update),
+      delete: compileInstanceRules(rules.delete)
+    };
+  }
+  return ret;
+}
+var authDataRef = new Proxy(
+  {},
+  {
+    get(_target, prop, _receiver) {
+      return staticParam("authData", prop);
+    }
+  }
+);
+var preMutationRowRef = new Proxy(
+  {},
+  {
+    get(_target, prop, _receiver) {
+      return staticParam("preMutationRow", prop);
+    }
+  }
+);
+
+// ../zero-schema/src/schema.ts
+function createSchema(schema) {
+  return schema;
+}
+
 // ../zql/src/query/escape-like.ts
 function escapeLike(val) {
   return val.replace(/[%_]/g, "\\$&");
@@ -11685,14 +12308,14 @@ var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pi
 
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
-var createOpSchema = valita_exports.object({
-  op: valita_exports.literal("create"),
+var insertOpSchema = valita_exports.object({
+  op: valita_exports.literal("insert"),
   tableName: valita_exports.string(),
   primaryKey: primaryKeySchema,
   value: rowSchema
 });
-var setOpSchema = valita_exports.object({
-  op: valita_exports.literal("set"),
+var upsertOpSchema = valita_exports.object({
+  op: valita_exports.literal("upsert"),
   tableName: valita_exports.string(),
   primaryKey: primaryKeySchema,
   value: rowSchema
@@ -11712,8 +12335,8 @@ var deleteOpSchema = valita_exports.object({
   value: primaryKeyValueRecordSchema
 });
 var crudOpSchema = valita_exports.union(
-  createOpSchema,
-  setOpSchema,
+  insertOpSchema,
+  upsertOpSchema,
   updateOpSchema2,
   deleteOpSchema
 );
@@ -13482,6 +14105,8 @@ var MemorySource = class {
     };
   }
   connect(sort, optionalFilters) {
+    const filteredOptionalFilters = filterOptionalFilters(optionalFilters);
+    const predicates = filteredOptionalFilters.filters.map((c) => createPredicate(c));
     const input = {
       getSchema: () => schema,
       fetch: (req) => this.#fetch(req, connection),
@@ -13492,11 +14117,8 @@ var MemorySource = class {
       destroy: () => {
         this.#disconnect(input);
       },
-      appliedFilters: false
+      appliedFilters: filteredOptionalFilters.allApplied
     };
-    const predicates = filteredOptionalFilters(
-      optionalFilters
-    ).filters.map((c) => createPredicate(c));
     const connection = {
       input,
       output: void 0,
@@ -13752,87 +14374,74 @@ function* generateWithOverlay(startAt, rows, constraint, overlay, compare) {
   yield* generateWithOverlayInner(rows, overlays, compare);
 }
 function computeOverlays(startAt, constraint, overlay, compare) {
-  let secondOverlay;
-  if (overlay?.change.type === "edit" && compare(overlay.change.row, overlay.change.oldRow) !== 0) {
-    [overlay, secondOverlay] = splitEditChange(overlay, compare);
+  let overlays = {
+    add: void 0,
+    remove: void 0
+  };
+  switch (overlay?.change.type) {
+    case "add":
+      overlays = {
+        add: overlay.change.row,
+        remove: void 0
+      };
+      break;
+    case "remove":
+      overlays = {
+        add: void 0,
+        remove: overlay.change.row
+      };
+      break;
+    case "edit":
+      overlays = {
+        add: overlay.change.row,
+        remove: overlay.change.oldRow
+      };
+      break;
   }
   if (startAt) {
-    overlay = overlayForStartAt(overlay, startAt, compare);
-    secondOverlay = overlayForStartAt(secondOverlay, startAt, compare);
+    overlays = overlaysForStartAt(overlays, startAt, compare);
   }
   if (constraint) {
-    overlay = overlayForConstraint(overlay, constraint);
-    secondOverlay = overlayForConstraint(secondOverlay, constraint);
-  }
-  if (secondOverlay !== void 0 && overlay === void 0) {
-    overlay = secondOverlay;
-    secondOverlay = void 0;
+    overlays = overlaysForConstraint(overlays, constraint);
   }
-  return [overlay, secondOverlay];
+  return overlays;
 }
-function overlayForStartAt(overlay, startAt, compare) {
-  if (!overlay) {
-    return void 0;
-  }
-  if (compare(overlay.change.row, startAt) < 0) {
-    return void 0;
-  }
-  return overlay;
-}
-function overlayForConstraint(overlay, constraint) {
-  if (!overlay) {
-    return void 0;
-  }
-  if (!valuesEqual(overlay.change.row[constraint.key], constraint.value)) {
-    return void 0;
-  }
-  return overlay;
-}
-function splitEditChange(overlay, compare) {
-  const { oldRow, row } = overlay.change;
-  const removeOverlay = {
-    outputIndex: overlay.outputIndex,
-    change: { type: "remove", row: oldRow }
+function overlaysForStartAt({ add, remove }, startAt, compare) {
+  const undefinedIfBeforeStartAt = (row) => row === void 0 || compare(row, startAt) < 0 ? void 0 : row;
+  return {
+    add: undefinedIfBeforeStartAt(add),
+    remove: undefinedIfBeforeStartAt(remove)
   };
-  const addOverlay = {
-    outputIndex: overlay.outputIndex,
-    change: { type: "add", row }
+}
+function overlaysForConstraint({ add, remove }, constraint) {
+  const undefinedIfDoesntMatchConstraint = (row) => row === void 0 || !valuesEqual(row[constraint.key], constraint.value) ? void 0 : row;
+  return {
+    add: undefinedIfDoesntMatchConstraint(add),
+    remove: undefinedIfDoesntMatchConstraint(remove)
   };
-  const cmp2 = compare(oldRow, row);
-  assert(cmp2 !== 0, "We should not split edit change with same PK");
-  if (cmp2 < 0) {
-    return [removeOverlay, addOverlay];
-  }
-  return [addOverlay, removeOverlay];
 }
 function* generateWithOverlayInner(rowIterator, overlays, compare) {
-  let [overlay, secondOverlay] = overlays;
+  let addOverlayYielded = false;
+  let removeOverlaySkipped = false;
   for (const row of rowIterator) {
-    if (overlay) {
-      if (overlay.change.type === "add" || overlay.change.type === "edit") {
-        const cmp2 = compare(overlay.change.row, row);
-        if (cmp2 < 0) {
-          yield { row: overlay.change.row, relationships: {} };
-          overlay = secondOverlay;
-          secondOverlay = void 0;
-        }
+    if (!addOverlayYielded && overlays.add) {
+      const cmp2 = compare(overlays.add, row);
+      if (cmp2 < 0) {
+        addOverlayYielded = true;
+        yield { row: overlays.add, relationships: {} };
       }
-      if (overlay?.change.type === "remove") {
-        const cmp2 = compare(overlay.change.row, row);
-        if (cmp2 < 0) {
-          overlay = secondOverlay;
-          secondOverlay = void 0;
-        } else if (cmp2 === 0) {
-          overlay = secondOverlay;
-          secondOverlay = void 0;
-          continue;
-        }
+    }
+    if (!removeOverlaySkipped && overlays.remove) {
+      const cmp2 = compare(overlays.remove, row);
+      if (cmp2 === 0) {
+        removeOverlaySkipped = true;
+        continue;
       }
     }
     yield { row, relationships: {} };
   }
-  if (overlay && overlay.change.type === "add") {
-    yield { row: overlay.change.row, relationships: {} };
+  if (!addOverlayYielded && overlays.add) {
+    yield { row: overlays.add, relationships: {} };
   }
 }
 var minValue = Symbol("min-value");
@@ -13867,7 +14476,7 @@ function compareBounds(a, b) {
   }
   return compareValues(a, b);
 }
-function filteredOptionalFilters(optionalFilters) {
+function filterOptionalFilters(optionalFilters) {
   if (optionalFilters) {
     if (optionalFilters.type === "or" && optionalFilters.conditions.length === 1) {
       optionalFilters = optionalFilters.conditions[0];
@@ -14075,7 +14684,7 @@ var ZeroContext = class {
 function makeCRUDMutate(schema, repMutate) {
   const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
   let inBatch = false;
-  const mutate = async (body) => {
+  const mutateBatch = async (body) => {
     if (inBatch) {
       throw new Error("Cannot call mutate inside a batch");
     }
@@ -14098,6 +14707,7 @@ function makeCRUDMutate(schema, repMutate) {
       throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
     }
   };
+  const mutate = {};
   for (const [name, tableSchema] of Object.entries(schema.tables)) {
     mutate[name] = makeEntityCRUDMutate(
       name,
@@ -14106,24 +14716,27 @@ function makeCRUDMutate(schema, repMutate) {
       assertNotInBatch
     );
   }
-  return mutate;
+  return {
+    mutate,
+    mutateBatch
+  };
 }
 function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
   return {
-    create: (value) => {
-      assertNotInBatch(tableName, "create");
+    insert: (value) => {
+      assertNotInBatch(tableName, "insert");
       const op = {
-        op: "create",
+        op: "insert",
         tableName,
         primaryKey,
         value
       };
       return zeroCRUD({ ops: [op] });
     },
-    set: (value) => {
-      assertNotInBatch(tableName, "set");
+    upsert: (value) => {
+      assertNotInBatch(tableName, "upsert");
       const op = {
-        op: "set",
+        op: "upsert",
         tableName,
         primaryKey,
         value
@@ -14155,9 +14768,9 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
 function makeBatchCRUDMutate(tableName, schema, ops) {
   const { primaryKey } = schema.tables[tableName];
   return {
-    create: (value) => {
+    insert: (value) => {
       const op = {
-        op: "create",
+        op: "insert",
         tableName,
         primaryKey,
         value
@@ -14165,9 +14778,9 @@ function makeBatchCRUDMutate(tableName, schema, ops) {
       ops.push(op);
       return promiseVoid;
     },
-    set: (value) => {
+    upsert: (value) => {
       const op = {
-        op: "set",
+        op: "upsert",
         tableName,
         primaryKey,
         value
@@ -14201,11 +14814,11 @@ function makeCRUDMutator(schema) {
   return async function zeroCRUDMutator(tx, crudArg) {
     for (const op of crudArg.ops) {
       switch (op.op) {
-        case "create":
-          await createImpl(tx, op, schema);
+        case "insert":
+          await insertImpl(tx, op, schema);
           break;
-        case "set":
-          await setImpl(tx, op, schema);
+        case "upsert":
+          await upsertImpl(tx, op, schema);
           break;
         case "update":
           await updateImpl(tx, op, schema);
@@ -14217,23 +14830,40 @@ function makeCRUDMutator(schema) {
     }
   };
 }
-async function createImpl(tx, arg, schema) {
+function defaultOptionalFieldsToNull(schema, value) {
+  let rv = value;
+  for (const name in schema.columns) {
+    if (rv[name] === void 0) {
+      rv = { ...rv, [name]: null };
+    }
+  }
+  return rv;
+}
+async function insertImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
     arg.tableName,
     schema.tables[arg.tableName].primaryKey,
     arg.value
   );
   if (!await tx.has(key)) {
-    await tx.set(key, arg.value);
+    const val = defaultOptionalFieldsToNull(
+      schema.tables[arg.tableName],
+      arg.value
+    );
+    await tx.set(key, val);
   }
 }
-async function setImpl(tx, arg, schema) {
+async function upsertImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
     arg.tableName,
     schema.tables[arg.tableName].primaryKey,
     arg.value
   );
-  await tx.set(key, arg.value);
+  const val = defaultOptionalFieldsToNull(
+    schema.tables[arg.tableName],
+    arg.value
+  );
+  await tx.set(key, val);
 }
 async function updateImpl(tx, arg, schema) {
   const key = toPrimaryKeyString(
@@ -14246,7 +14876,12 @@ async function updateImpl(tx, arg, schema) {
     return;
   }
   const update = arg.value;
-  const next = { ...prev, ...update };
+  const next = { ...prev };
+  for (const k in update) {
+    if (update[k] !== void 0) {
+      next[k] = update[k];
+    }
+  }
   await tx.set(key, next);
 }
 async function deleteImpl(tx, arg, schema) {
@@ -14277,6 +14912,9 @@ function shouldEnableAnalytics(server, enableAnalytics = true) {
 function toWSString(url) {
   return "ws" + url.slice(4);
 }
+function appendPath(url, toAppend) {
+  return url + (url.endsWith("/") ? toAppend.substring(1) : toAppend);
+}
 
 // ../zero-client/src/client/log-options.ts
 import {
@@ -14503,7 +15141,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.5.2024110200+4ba53b";
+var version2 = "0.6.2024111700+e4dfbb";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14537,9 +15175,9 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
     };
   }
   const serverURL = new URL(server);
-  const socketHostname = serverURL.hostname;
-  const datadogServiceLabel = socketHostname.endsWith(ZERO_SASS_DOMAIN) ? socketHostname.substring(0, socketHostname.length - ZERO_SASS_DOMAIN.length).toLowerCase() : socketHostname;
-  const baseURL = new URL("/api/logs/v0/log", server);
+  const { hostname } = serverURL;
+  const datadogServiceLabel = hostname.endsWith(ZERO_SASS_DOMAIN) ? hostname.substring(0, hostname.length - ZERO_SASS_DOMAIN.length).toLowerCase() : hostname;
+  const baseURL = new URL(appendPath(server, "/logs/v0/log"));
   const logLevel = consoleLogLevel === "debug" ? "debug" : "info";
   const logSink = new TeeLogSink2([
     new LevelFilterLogSink(consoleLogSink4, consoleLogLevel),
@@ -14789,30 +15427,6 @@ var State = class {
   }
 };
 
-// ../zero-client/src/client/normalized-schema.ts
-function normalizeSchema(schema) {
-  if (schema instanceof NormalizedSchema) {
-    return schema;
-  }
-  return new NormalizedSchema(schema);
-}
-var NormalizedSchema = class {
-  version;
-  tables;
-  constructor(schema) {
-    this.version = schema.version;
-    this.tables = normalizeTables(schema.tables);
-  }
-};
-function normalizeTables(tables) {
-  const rv = {};
-  const tableSchemaCache = /* @__PURE__ */ new Map();
-  for (const [name, table] of sortedEntries(tables)) {
-    rv[name] = normalizeTableSchemaWithCache(table, name, tableSchemaCache);
-  }
-  return rv;
-}
-
 // ../zero-client/src/client/query-manager.ts
 var QueryManager = class {
   #clientID;
@@ -14993,7 +15607,7 @@ function isAuthErrorKind(kind) {
 // ../zero-client/src/client/server-option.ts
 function validateServerParam(paramName, server) {
   const expectedProtocol = "http";
-  const forExample = () => ` For example: "${expectedProtocol}s://myapp-myteam.zero.ms/".`;
+  const forExample = (path2 = "") => ` For example: "${expectedProtocol}s://myapp-myteam.zero.ms/${path2}".`;
   if (!server.startsWith(`${expectedProtocol}://`) && !server.startsWith(`${expectedProtocol}s://`)) {
     throw new Error(
       `ZeroOptions.${paramName} must use the "${expectedProtocol}" or "${expectedProtocol}s" scheme.`
@@ -15008,9 +15622,18 @@ function validateServerParam(paramName, server) {
     );
   }
   const urlString = url.toString();
-  if (url.pathname !== "/") {
+  const pathComponents = url.pathname.split("/");
+  if (pathComponents[0] === "") {
+    pathComponents.shift();
+  }
+  if (pathComponents[pathComponents.length - 1] === "") {
+    pathComponents.pop();
+  }
+  if (pathComponents.length > 1) {
     throw new Error(
-      `ZeroOptions.${paramName} must not contain a path component (other than "/").${forExample()}`
+      `ZeroOptions.${paramName} may have at most one path component.${forExample(
+        "zero"
+      )}`
     );
   }
   for (const [property, invalidEndsWith] of [
@@ -15050,6 +15673,7 @@ var PokeHandler = class {
   // order poke errors.
   #pokeLock = new Lock3();
   #schema;
+  #raf = getBrowserGlobalMethod("requestAnimationFrame") ?? rafFallback;
   constructor(replicachePoke, onPokeError, clientID, schema, lc) {
     this.#replicachePoke = replicachePoke;
     this.#onPokeError = onPokeError;
@@ -15107,7 +15731,7 @@ var PokeHandler = class {
   #startPlaybackLoop() {
     this.#lc.debug?.("starting playback loop");
     this.#pokePlaybackLoopRunning = true;
-    requestAnimationFrame(this.#rafCallback);
+    this.#raf(this.#rafCallback);
   }
   #rafCallback = async () => {
     const rafLC = this.#lc.withContext("rafAt", Math.floor(performance.now()));
@@ -15116,7 +15740,7 @@ var PokeHandler = class {
       this.#pokePlaybackLoopRunning = false;
       return;
     }
-    requestAnimationFrame(this.#rafCallback);
+    this.#raf(this.#rafCallback);
     const start = performance.now();
     rafLC.debug?.(
       "raf fired, processing pokes.  Since last raf",
@@ -15305,6 +15929,12 @@ function rowsPatchOpToReplicachePatchOp(op, schema) {
       throw new Error("to be implemented");
   }
 }
+function rafFallback(callback) {
+  setTimeout(callback, 0);
+}
+
+// ../zero-client/src/client/protocol-version.ts
+var PROTOCOL_VERSION = 1;
 
 // ../zero-client/src/client/zero.ts
 var onSetConnectionStateSymbol = Symbol();
@@ -15318,7 +15948,6 @@ var DEFAULT_DISCONNECT_HIDDEN_DELAY_MS = 5e3;
 var CONNECT_TIMEOUT_MS = 1e4;
 var CHECK_CONNECTIVITY_ON_ERROR_FREQUENCY = 6;
 var NULL_LAST_MUTATION_ID_SENT = { clientID: "", id: -1 };
-var REFLECT_VERSION = 1;
 function convertOnUpdateNeededReason(reason) {
   return { type: reason.type };
 }
@@ -15502,7 +16131,8 @@ var Zero = class {
     const server = getServer(options.server);
     this.#enableAnalytics = shouldEnableAnalytics(
       server,
-      options.enableAnalytics
+      false
+      // Reenable analytics
     );
     if (jurisdiction !== void 0 && jurisdiction !== "eu") {
       throw new Error('ZeroOptions.jurisdiction must be "eu" if present.');
@@ -15572,7 +16202,12 @@ var Zero = class {
         reason ?? ON_CLIENT_STATE_NOT_FOUND_REASON_CLIENT
       );
     };
-    this.mutate = makeCRUDMutate(normalizedSchema, rep.mutate);
+    const { mutate, mutateBatch } = makeCRUDMutate(
+      normalizedSchema,
+      rep.mutate
+    );
+    this.mutate = mutate;
+    this.mutateBatch = mutateBatch;
     this.#queryManager = new QueryManager(
       rep.clientID,
       (msg) => this.#sendChangeDesiredQueries(msg),
@@ -15666,30 +16301,42 @@ var Zero = class {
     return this.#rep.clientGroupID;
   }
   /**
-   * Provides facilities to write data to Zero.
+   * Provides simple "CRUD" mutations for the tables in the schema.
    *
-   * `mutate` is a function as well as a "namespace" object for doing CRUD style
-   * mutations. When used as a function it is used to batch multiple mutations.
+   * Each table has `create`, `set`, `update`, and `delete` methods.
    *
    * ```ts
-   * await zero.mutate.issue.create({id: '1', title: 'First issue'});
+   * await zero.mutate.issue.create({id: '1', title: 'First issue', priority: 'high'});
    * await zero.mutate.comment.create({id: '1', text: 'First comment', issueID: '1'});
+   * ```
+   *
+   * The `update` methods support partials. Unspecified or `undefined` fields
+   * are left unchanged:
    *
-   * // or as a function:
-   * await zero.mutate(m => {
+   * ```ts
+   * // Priority left unchanged.
+   * await zero.mutate.issue.update({id: '1', title: 'Updated title'});
+   * ```
+   */
+  mutate;
+  /**
+   * Provides a way to batch multiple CRUD mutations together:
+   *
+   * ```ts
+   * await zero.mutateBatch(m => {
    *   await m.issue.create({id: '1', title: 'First issue'});
    *   await m.comment.create({id: '1', text: 'First comment', issueID: '1'});
    * });
    * ```
    *
-   * The benefit of using the function form is that it allows you to batch
-   * multiple mutations together. This can be more efficient than making
-   * individual calls to `create`, `update`, `set`, and `delete`.
+   * Batch sends all mutations in a single transaction. If one fails, all are
+   * rolled back together. Batch can also be more efficient than making many
+   * individual mutations.
    *
-   * The function form of `mutate` is not allowed to be called inside another
-   * `mutate` function. Doing so will throw an error.
+   * `mutateBatch` is not allowed inside another `mutateBatch` call. Doing so
+   * will throw an error.
    */
-  mutate;
+  mutateBatch;
   /**
    * Whether this Zero instance has been closed. Once a Zero instance has
    * been closed it no longer syncs and you can no longer read or write data out
@@ -15760,11 +16407,8 @@ var Zero = class {
         rejectInvalidMessage();
     }
   };
-  #onOpen = (e) => {
-    const l = addWebSocketIDFromSocketToLogContext(
-      e.target,
-      this.#lc
-    );
+  #onOpen = () => {
+    const l = addWebSocketIDFromSocketToLogContext(this.#socket, this.#lc);
     if (this.#connectStart === void 0) {
       l.error?.(
         "Got open event but connect start time is undefined. This should not happen."
@@ -15779,10 +16423,7 @@ var Zero = class {
     }
   };
   #onClose = (e) => {
-    const l = addWebSocketIDFromSocketToLogContext(
-      e.target,
-      this.#lc
-    );
+    const l = addWebSocketIDFromSocketToLogContext(this.#socket, this.#lc);
     const { code, reason, wasClean } = e;
     l.info?.("Got socket close event", { code, reason, wasClean });
     const closeKind = wasClean ? "CleanClose" : "AbruptClose";
@@ -16264,16 +16905,6 @@ var Zero = class {
       }
       if (gotError) {
         this.#setOnline(false);
-        let cfGetCheckSucceeded = false;
-        const cfGetCheckURL = new URL(this.#server);
-        cfGetCheckURL.pathname = "/api/canary/v0/get";
-        cfGetCheckURL.searchParams.set("id", nanoid());
-        const cfGetCheckController = new AbortController();
-        fetch(cfGetCheckURL, { signal: cfGetCheckController.signal }).then((_) => {
-          cfGetCheckSucceeded = true;
-        }).catch((_) => {
-          cfGetCheckSucceeded = false;
-        });
         lc.debug?.(
           "Sleeping",
           RUN_LOOP_INTERVAL_MS,
@@ -16281,13 +16912,6 @@ var Zero = class {
           this.#connectionState
         );
         await sleep(RUN_LOOP_INTERVAL_MS);
-        cfGetCheckController.abort();
-        if (!cfGetCheckSucceeded) {
-          lc.info?.(
-            "Canary request failed, resetting total time to connect start time."
-          );
-          this.#totalToConnectStart = void 0;
-        }
       }
     }
   }
@@ -16420,8 +17044,9 @@ var Zero = class {
   }
 };
 async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, jurisdiction, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8) {
-  const url = new URL(socketOrigin);
-  url.pathname = `/api/sync/v${REFLECT_VERSION}/connect`;
+  const url = new URL(
+    appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
+  );
   const { searchParams } = url;
   searchParams.set("clientID", clientID);
   searchParams.set("clientGroupID", clientGroupID);
@@ -16484,12 +17109,10 @@ export {
   makeIDBName,
   dropDatabase,
   dropAllDatabases,
-  cmp,
-  and,
-  or,
-  not,
-  QueryImpl,
+  createTableSchema,
+  defineAuthorization,
+  createSchema,
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-INJ4WJHS.js.map
+//# sourceMappingURL=chunk-PIFWXXO2.js.map