@rocicorp/zero 0.11.2025011801 → 0.11.2025012200

package/out/{chunk-QV5ZN4MA.js → chunk-5OVHF6ZM.js}

@@ -896,6 +896,7 @@ function dropIDBStore(name) {
 }
 
 // ../replicache/src/replicache-impl.ts
+import { Lock as Lock2 } from "@rocicorp/lock";
 import { consoleLogSink as consoleLogSink2 } from "@rocicorp/logger";
 import { resolver as resolver6 } from "@rocicorp/resolver";
 
@@ -5111,7 +5112,6 @@ function handlePullResponseV1(lc, store, expectedBaseCookie, response, clientID,
         );
       }
       if (Object.keys(response.lastMutationIDChanges).length > 0) {
-        console.log(response.lastMutationIDChanges);
         lc.error?.(
           `handlePullResponse: cookie ${JSON.stringify(
             baseCookie
@@ -7254,7 +7254,7 @@ var ReplicacheImpl = class {
   #idbDatabases;
   #lc;
   #closeAbortController = new AbortController();
-  #persistIsRunning = false;
+  #persistLock = new Lock2();
   #enableScheduledPersist;
   #enableScheduledRefresh;
   #enablePullAndPushInOpen;
@@ -7946,11 +7946,9 @@ var ReplicacheImpl = class {
     const { syncHead, httpRequestInfo } = beginPullResponse;
     return { requestID, syncHead, ok: httpRequestInfo.httpStatusCode === 200 };
   }
-  async persist() {
-    assert(!this.#persistIsRunning);
-    this.#persistIsRunning = true;
-    try {
-      const { clientID: clientID2 } = this;
+  persist() {
+    return this.#persistLock.withLock(async () => {
+      const { clientID } = this;
       await this.#ready;
       if (this.#closed) {
         return;
@@ -7958,29 +7956,26 @@ var ReplicacheImpl = class {
       try {
         await persistDD31(
           this.#lc,
-          clientID2,
+          clientID,
           this.memdag,
           this.perdag,
           this.#mutatorRegistry,
-          () => this.closed,
+          () => this.#closed,
           Latest
         );
       } catch (e) {
         if (e instanceof ClientStateNotFoundError) {
-          this.#clientStateNotFoundOnClient(clientID2);
+          this.#clientStateNotFoundOnClient(clientID);
         } else if (this.#closed) {
           this.#lc.debug?.("Exception persisting during close", e);
         } else {
           throw e;
         }
       }
-    } finally {
-      this.#persistIsRunning = false;
-    }
-    const { clientID } = this;
-    const clientGroupID = await this.#clientGroupIDPromise;
-    assert(clientGroupID);
-    this.#onPersist({ clientID, clientGroupID });
+      const clientGroupID = await this.#clientGroupIDPromise;
+      assert(clientGroupID);
+      this.#onPersist({ clientID, clientGroupID });
+    });
   }
   async refresh() {
     await this.#ready;
@@ -8320,6 +8315,176 @@ function getKVStoreProvider(lc, kvStore) {
 // ../replicache/src/mod.ts
 import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
 
+// ../zero-schema/src/builder/relationship-builder.ts
+function relationships(table2, cb) {
+  const relationships2 = cb({ many, one });
+  return {
+    name: table2.schema.name,
+    relationships: relationships2
+  };
+}
+function many(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "many"
+  }));
+}
+function one(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "one"
+  }));
+}
+
+// ../zero-schema/src/builder/table-builder.ts
+function table(name) {
+  return new TableBuilder({
+    name,
+    columns: {},
+    primaryKey: []
+  });
+}
+function string7() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+function number4() {
+  return new ColumnBuilder({
+    type: "number",
+    optional: false,
+    customType: null
+  });
+}
+function boolean3() {
+  return new ColumnBuilder({
+    type: "boolean",
+    optional: false,
+    customType: null
+  });
+}
+function json() {
+  return new ColumnBuilder({
+    type: "json",
+    optional: false,
+    customType: null
+  });
+}
+function enumeration() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+var TableBuilder = class {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  columns(columns) {
+    const columnSchemas = Object.fromEntries(
+      Object.entries(columns).map(([k, v2]) => [k, v2.schema])
+    );
+    return new TableBuilderWithColumns({
+      ...this.#schema,
+      columns: columnSchemas
+    });
+  }
+};
+var TableBuilderWithColumns = class _TableBuilderWithColumns {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  primaryKey(...pkColumnNames) {
+    return new _TableBuilderWithColumns({
+      ...this.#schema,
+      primaryKey: pkColumnNames
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+  build() {
+    if (this.#schema.primaryKey.length === 0) {
+      throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
+    }
+    return this.#schema;
+  }
+};
+var ColumnBuilder = class _ColumnBuilder {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  optional() {
+    return new _ColumnBuilder({
+      ...this.#schema,
+      optional: true
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+};
+
+// ../zero-schema/src/builder/schema-builder.ts
+function createSchema(version3, options) {
+  const retTables = {};
+  const retRelationships = {};
+  options.tables.forEach((table2) => {
+    if (retTables[table2.schema.name]) {
+      throw new Error(
+        `Table "${table2.schema.name}" is defined more than once in the schema`
+      );
+    }
+    retTables[table2.schema.name] = table2.build();
+  });
+  options.relationships?.forEach((relationships2) => {
+    if (retRelationships[relationships2.name]) {
+      throw new Error(
+        `Relationships for table "${relationships2.name}" are defined more than once in the schema`
+      );
+    }
+    retRelationships[relationships2.name] = relationships2.relationships;
+    checkRelationship(
+      relationships2.relationships,
+      relationships2.name,
+      retTables
+    );
+  });
+  return {
+    version: version3,
+    tables: retTables,
+    relationships: retRelationships
+  };
+}
+function checkRelationship(relationships2, tableName, tables) {
+  Object.entries(relationships2).forEach(([name, rel]) => {
+    let source = tables[tableName];
+    rel.forEach((connection) => {
+      if (!tables[connection.destSchema]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", destination table "${connection.destSchema}" is missing in the schema`
+        );
+      }
+      if (!source.columns[connection.sourceField[0]]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", the source field "${connection.sourceField[0]}" is missing in the table schema "${source.name}"`
+        );
+      }
+      source = tables[connection.destSchema];
+    });
+  });
+}
+
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
@@ -9207,15 +9372,39 @@ function maybeSplitAndPushEditChange(change, predicate, output) {
   }
 }
 
+// ../zql/src/ivm/filter-push.ts
+function filterPush(change, output, predicate) {
+  if (!predicate) {
+    output.push(change);
+    return;
+  }
+  switch (change.type) {
+    case "add":
+    case "remove":
+      if (predicate(change.node.row)) {
+        output.push(change);
+      }
+      break;
+    case "child":
+      if (predicate(change.row)) {
+        output.push(change);
+      }
+      break;
+    case "edit":
+      maybeSplitAndPushEditChange(change, predicate, output);
+      break;
+    default:
+      unreachable(change);
+  }
+}
+
 // ../zql/src/ivm/filter.ts
 var Filter = class {
   #input;
-  #mode;
   #predicate;
   #output = throwOutput;
-  constructor(input, mode, predicate) {
+  constructor(input, predicate) {
     this.#input = input;
-    this.#mode = mode;
     this.#predicate = predicate;
     input.setOutput(this);
   }
@@ -9236,30 +9425,13 @@ var Filter = class {
   }
   *#filter(stream) {
     for (const node of stream) {
-      if (this.#mode === "push-only" || this.#predicate(node.row)) {
+      if (this.#predicate(node.row)) {
         yield node;
       }
     }
   }
   push(change) {
-    switch (change.type) {
-      case "add":
-      case "remove":
-        if (this.#predicate(change.node.row)) {
-          this.#output.push(change);
-        }
-        break;
-      case "child":
-        if (this.#predicate(change.row)) {
-          this.#output.push(change);
-        }
-        break;
-      case "edit":
-        maybeSplitAndPushEditChange(change, this.#predicate, this.#output);
-        break;
-      default:
-        unreachable(change);
-    }
+    filterPush(change, this.#output, this.#predicate);
   }
 };
 
@@ -10315,7 +10487,7 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   }
   const conn = source.connect(must(ast.orderBy), ast.where);
   let end = conn;
-  const { appliedFilters } = conn;
+  const { fullyAppliedFilters } = conn;
   ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
   if (ast.start) {
     end = new Skip(end, ast.start);
@@ -10323,8 +10495,8 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
     end = applyCorrelatedSubQuery(csq, delegate, end);
   }
-  if (ast.where) {
-    end = applyWhere(end, ast.where, appliedFilters, delegate);
+  if (ast.where && !fullyAppliedFilters) {
+    end = applyWhere(end, ast.where, delegate);
   }
   if (ast.limit) {
     end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
@@ -10336,45 +10508,43 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
   }
   return end;
 }
-function applyWhere(input, condition, appliedFilters, delegate) {
+function applyWhere(input, condition, delegate) {
   switch (condition.type) {
     case "and":
-      return applyAnd(input, condition, appliedFilters, delegate);
+      return applyAnd(input, condition, delegate);
     case "or":
-      return applyOr(input, condition, appliedFilters, delegate);
+      return applyOr(input, condition, delegate);
     case "correlatedSubquery":
       return applyCorrelatedSubqueryCondition(input, condition, delegate);
     case "simple":
-      return applySimpleCondition(input, condition, appliedFilters);
+      return applySimpleCondition(input, condition);
   }
 }
-function applyAnd(input, condition, appliedFilters, delegate) {
+function applyAnd(input, condition, delegate) {
   for (const subCondition of condition.conditions) {
-    input = applyWhere(input, subCondition, appliedFilters, delegate);
+    input = applyWhere(input, subCondition, delegate);
   }
   return input;
 }
-function applyOr(input, condition, appliedFilters, delegate) {
+function applyOr(input, condition, delegate) {
   const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
   if (subqueryConditions.length === 0) {
-    return otherConditions.length > 0 ? new Filter(
+    return new Filter(
       input,
-      appliedFilters ? "push-only" : "all",
       createPredicate({
         type: "or",
         conditions: otherConditions
       })
-    ) : new FanIn(new FanOut(input), []);
+    );
   }
   const fanOut = new FanOut(input);
   const branches = subqueryConditions.map(
-    (subCondition) => applyWhere(fanOut, subCondition, appliedFilters, delegate)
+    (subCondition) => applyWhere(fanOut, subCondition, delegate)
   );
   if (otherConditions.length > 0) {
     branches.push(
       new Filter(
         fanOut,
-        appliedFilters ? "push-only" : "all",
         createPredicate({
           type: "or",
           conditions: otherConditions
@@ -10405,12 +10575,8 @@ function isNotAndDoesNotContainSubquery(condition) {
   assert(condition.type !== "or", "where conditions are expected to be in DNF");
   return true;
 }
-function applySimpleCondition(input, condition, appliedFilters) {
-  return new Filter(
-    input,
-    appliedFilters ? "push-only" : "all",
-    createPredicate(condition)
-  );
+function applySimpleCondition(input, condition) {
+  return new Filter(input, createPredicate(condition));
 }
 function applyCorrelatedSubQuery(sq, delegate, end) {
   assert(sq.subquery.alias, "Subquery must have an alias");
@@ -10871,7 +11037,9 @@ var AbstractQuery = class {
   where(fieldOrExpressionFactory, opOrValue, value) {
     let cond;
     if (typeof fieldOrExpressionFactory === "function") {
-      cond = fieldOrExpressionFactory(new ExpressionBuilder(this._exists));
+      cond = fieldOrExpressionFactory(
+        new ExpressionBuilder(this._exists)
+      );
     } else {
       assert(opOrValue !== void 0, "Invalid condition");
       cond = cmp(fieldOrExpressionFactory, opOrValue, value);
@@ -11298,162 +11466,6 @@ function baseTracker(anchor) {
 var authDataRef = baseTracker("authData");
 var preMutationRowRef = baseTracker("preMutationRow");
 
-// ../zero-schema/src/builder/table-builder.ts
-function table(name) {
-  return new TableBuilder({
-    name,
-    columns: {},
-    primaryKey: []
-  });
-}
-function string8() {
-  return new ColumnBuilder({
-    type: "string",
-    optional: false,
-    customType: null
-  });
-}
-function number5() {
-  return new ColumnBuilder({
-    type: "number",
-    optional: false,
-    customType: null
-  });
-}
-function boolean4() {
-  return new ColumnBuilder({
-    type: "boolean",
-    optional: false,
-    customType: null
-  });
-}
-function json() {
-  return new ColumnBuilder({
-    type: "json",
-    optional: false,
-    customType: null
-  });
-}
-function enumeration() {
-  return new ColumnBuilder({
-    type: "string",
-    optional: false,
-    customType: null
-  });
-}
-var TableBuilder = class {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  columns(columns) {
-    const columnSchemas = Object.fromEntries(
-      Object.entries(columns).map(([k, v2]) => [k, v2.schema])
-    );
-    return new TableBuilderWithColumns({
-      ...this.#schema,
-      columns: columnSchemas
-    });
-  }
-};
-var TableBuilderWithColumns = class _TableBuilderWithColumns {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  primaryKey(...pkColumnNames) {
-    return new _TableBuilderWithColumns({
-      ...this.#schema,
-      primaryKey: pkColumnNames
-    });
-  }
-  get schema() {
-    return this.#schema;
-  }
-  build() {
-    if (this.#schema.primaryKey.length === 0) {
-      throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
-    }
-    return this.#schema;
-  }
-};
-var ColumnBuilder = class _ColumnBuilder {
-  #schema;
-  constructor(schema) {
-    this.#schema = schema;
-  }
-  optional() {
-    return new _ColumnBuilder({
-      ...this.#schema,
-      optional: true
-    });
-  }
-  get schema() {
-    return this.#schema;
-  }
-};
-
-// ../zero-schema/src/builder/schema-builder.ts
-function createSchema(version3, tables, relationships2) {
-  const retTables = {};
-  const retRelationships = {};
-  Object.values(tables).forEach((table2) => {
-    retTables[table2.schema.name] = table2.build();
-  });
-  Object.values(relationships2 ?? {}).forEach((relationship) => {
-    retRelationships[relationship.name] = relationship.relationships;
-    checkRelationship(relationship.relationships, relationship.name, retTables);
-  });
-  return {
-    version: version3,
-    tables: retTables,
-    relationships: retRelationships
-  };
-}
-function checkRelationship(relationships2, tableName, tables) {
-  Object.entries(relationships2).forEach(([name, rel]) => {
-    let source = tables[tableName];
-    rel.forEach((connection) => {
-      if (!tables[connection.destSchema]) {
-        throw new Error(
-          `For relationship "${tableName}"."${name}", destination table "${connection.destSchema}" is missing in the schema`
-        );
-      }
-      if (!source.columns[connection.sourceField[0]]) {
-        throw new Error(
-          `For relationship "${tableName}"."${name}", the source field "${connection.sourceField[0]}" is missing in the table schema "${source.name}"`
-        );
-      }
-      source = tables[connection.destSchema];
-    });
-  });
-}
-
-// ../zero-schema/src/builder/relationship-builder.ts
-function relationships(table2, cb) {
-  const relationships2 = cb({ many, one });
-  return {
-    name: table2.schema.name,
-    relationships: relationships2
-  };
-}
-function many(...args) {
-  return args.map((arg) => ({
-    sourceField: arg.sourceField,
-    destField: arg.destField,
-    destSchema: arg.destSchema.schema.name,
-    cardinality: "many"
-  }));
-}
-function one(...args) {
-  return args.map((arg) => ({
-    sourceField: arg.sourceField,
-    destField: arg.destField,
-    destSchema: arg.destSchema.schema.name,
-    cardinality: "one"
-  }));
-}
-
 // ../zql/src/query/escape-like.ts
 function escapeLike(val) {
   return val.replace(/[%_]/g, "\\$&");
@@ -12398,8 +12410,8 @@ var MemorySource = class {
       compareRows: connection.compareRows
     };
   }
-  connect(sort, optionalFilters) {
-    const transformedFilters = transformFilters(optionalFilters);
+  connect(sort, filters) {
+    const transformedFilters = transformFilters(filters);
     const input = {
       getSchema: () => schema,
       fetch: (req) => this.#fetch(req, connection),
@@ -12410,7 +12422,7 @@ var MemorySource = class {
       destroy: () => {
         this.#disconnect(input);
       },
-      appliedFilters: !transformedFilters.conditionsRemoved
+      fullyAppliedFilters: !transformedFilters.conditionsRemoved
     };
     const connection = {
       input,
@@ -12572,10 +12584,13 @@ var MemorySource = class {
         relationships: {}
       }
     };
-    for (const [outputIndex, { output }] of this.#connections.entries()) {
+    for (const [
+      outputIndex,
+      { output, filters }
+    ] of this.#connections.entries()) {
       if (output) {
         this.#overlay = { outputIndex, change };
-        output.push(outputChange);
+        filterPush(outputChange, output, filters?.predicate);
         yield;
       }
     }
@@ -13179,7 +13194,7 @@ import {
 } from "@rocicorp/logger";
 
 // ../datadog/src/datadog-log-sink.ts
-import { Lock as Lock2 } from "@rocicorp/lock";
+import { Lock as Lock3 } from "@rocicorp/lock";
 var DD_BASE_URL = new URL(
   "https://http-intake.logs.datadoghq.com/api/v2/logs"
 );
@@ -13198,7 +13213,7 @@ var DatadogLogSink = class {
   #interval;
   #baseURL;
   #timerID = 0;
-  #flushLock = new Lock2();
+  #flushLock = new Lock3();
   constructor(options) {
     const {
       apiKey,
@@ -13397,7 +13412,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.11.2025011801+0c3f2d";
+var version2 = "0.11.2025012200+592c81";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14017,7 +14032,7 @@ function getServer(server) {
 }
 
 // ../zero-client/src/client/zero-poke-handler.ts
-import { Lock as Lock3 } from "@rocicorp/lock";
+import { Lock as Lock4 } from "@rocicorp/lock";
 var PokeHandler = class {
   #replicachePoke;
   #onPokeError;
@@ -14029,7 +14044,7 @@ var PokeHandler = class {
   #lastRafPerfTimestamp = 0;
   // Serializes calls to this.#replicachePoke otherwise we can cause out of
   // order poke errors.
-  #pokeLock = new Lock3();
+  #pokeLock = new Lock4();
   #schema;
   #raf = getBrowserGlobalMethod("requestAnimationFrame") ?? rafFallback;
   constructor(replicachePoke, onPokeError, clientID, schema, lc) {
@@ -15424,18 +15439,18 @@ export {
   makeIDBName,
   dropDatabase,
   dropAllDatabases,
-  ANYONE_CAN,
-  NOBODY_CAN,
-  definePermissions,
+  relationships,
   table,
-  string8 as string,
-  number5 as number,
-  boolean4 as boolean,
+  string7 as string,
+  number4 as number,
+  boolean3 as boolean,
   json,
   enumeration,
   createSchema,
-  relationships,
+  ANYONE_CAN,
+  NOBODY_CAN,
+  definePermissions,
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-QV5ZN4MA.js.map
+//# sourceMappingURL=chunk-5OVHF6ZM.js.map