@rocicorp/zero 0.16.2025022601 → 0.17.2025022800

package/out/chunk-P3NUVEQJ.js

@@ -0,0 +1,3578 @@
+import {
+  hasOwn
+} from "./chunk-HARIWJ2J.js";
+import {
+  applyChange,
+  assert,
+  assertObject,
+  assertString,
+  compareValues,
+  drainStreams,
+  must,
+  normalizeUndefined,
+  throwInvalidType,
+  unreachable,
+  valuesEqual
+} from "./chunk-Q6D7EOS6.js";
+import {
+  __export,
+  __reExport
+} from "./chunk-424PT5DM.js";
+
+// ../shared/src/valita.ts
+var valita_exports = {};
+__export(valita_exports, {
+  assert: () => assert2,
+  deepPartial: () => deepPartial,
+  instanceOfAbstractType: () => instanceOfAbstractType,
+  is: () => is,
+  parse: () => parse,
+  readonly: () => readonly,
+  readonlyArray: () => readonlyArray,
+  readonlyObject: () => readonlyObject,
+  readonlyRecord: () => readonlyRecord,
+  test: () => test,
+  testOptional: () => testOptional
+});
+__reExport(valita_exports, valita_star);
+import * as v from "@badrap/valita";
+import * as valita_star from "@badrap/valita";
+function toDisplay(value) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return JSON.stringify(value);
+    case "undefined":
+      return "undefined";
+    case "bigint":
+      return value.toString() + "n";
+    default:
+      if (value === null) {
+        return "null";
+      }
+      if (Array.isArray(value)) {
+        return "array";
+      }
+      return typeof value;
+  }
+}
+function toDisplayAtPath(v2, path2) {
+  if (!path2?.length) {
+    return toDisplay(v2);
+  }
+  let cur = v2;
+  for (const p of path2) {
+    cur = cur[p];
+  }
+  return toDisplay(cur);
+}
+function displayList(word, expected, toDisplay2 = (x) => String(x)) {
+  if (expected.length === 1) {
+    return toDisplay2(expected[0]);
+  }
+  const suffix = `${toDisplay2(
+    expected[expected.length - 2]
+  )} ${word} ${toDisplay2(expected[expected.length - 1])}`;
+  if (expected.length === 2) {
+    return suffix;
+  }
+  return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
+}
+function getMessage(err2, v2, schema, mode) {
+  const firstIssue = err2.issues[0];
+  const { path: path2 } = firstIssue;
+  const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
+  switch (firstIssue.code) {
+    case "invalid_type":
+      return `Expected ${displayList(
+        "or",
+        firstIssue.expected
+      )}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
+    case "missing_value": {
+      const atPath2 = path2 && path2.length > 1 ? ` at ${path2.slice(0, -1).join(".")}` : "";
+      if (firstIssue.path?.length) {
+        return `Missing property ${firstIssue.path.at(-1)}${atPath2}`;
+      }
+      return `TODO Unknown missing property${atPath2}`;
+    }
+    case "invalid_literal":
+      return `Expected literal value ${displayList(
+        "or",
+        firstIssue.expected,
+        toDisplay
+      )}${atPath} Got ${toDisplayAtPath(v2, path2)}`;
+    case "invalid_length": {
+      return `Expected array with length ${firstIssue.minLength === firstIssue.maxLength ? firstIssue.minLength : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`}${atPath}. Got array with length ${v2.length}`;
+    }
+    case "unrecognized_keys":
+      if (firstIssue.keys.length === 1) {
+        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;
+      }
+      return `Unexpected properties ${displayList(
+        "and",
+        firstIssue.keys
+      )}${atPath}`;
+    case "invalid_union":
+      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
+    case "custom_error": {
+      const { error } = firstIssue;
+      const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
+      return `${message}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
+    }
+  }
+}
+function getDeepestUnionParseError(value, schema, mode) {
+  const failures = [];
+  for (const type of schema.options) {
+    const r = type.try(value, { mode });
+    if (!r.ok) {
+      failures.push({ type, err: r });
+    }
+  }
+  if (failures.length) {
+    failures.sort(pathCmp);
+    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
+      return getMessage(failures[0].err, value, failures[0].type, mode);
+    }
+  }
+  try {
+    const str = JSON.stringify(value);
+    return `Invalid union value: ${str}`;
+  } catch (e) {
+    return `Invalid union value`;
+  }
+}
+function pathCmp(a, b) {
+  const aPath = a.err.issues[0].path;
+  const bPath = b.err.issues[0].path;
+  if (aPath.length !== bPath.length) {
+    return bPath.length - aPath.length;
+  }
+  for (let i = 0; i < aPath.length; i++) {
+    if (bPath[i] > aPath[i]) {
+      return -1;
+    }
+    if (bPath[i] < aPath[i]) {
+      return 1;
+    }
+  }
+  return 0;
+}
+function parse(value, schema, mode) {
+  const res = test(value, schema, mode);
+  if (!res.ok) {
+    throw new TypeError(res.error);
+  }
+  return res.value;
+}
+function is(value, schema, mode) {
+  return test(value, schema, mode).ok;
+}
+function assert2(value, schema, mode) {
+  parse(value, schema, mode);
+}
+function test(value, schema, mode) {
+  const res = schema.try(value, mode ? { mode } : void 0);
+  if (!res.ok) {
+    return {
+      ok: false,
+      error: getMessage(res, value, schema, mode)
+    };
+  }
+  return res;
+}
+function testOptional(value, schema, mode) {
+  let flags = 1;
+  if (mode === "passthrough") {
+    flags = 0;
+  } else if (mode === "strip") {
+    flags = 2;
+  }
+  const res = schema.func(value, flags);
+  if (res === void 0) {
+    return { ok: true, value };
+  } else if (res.ok) {
+    return res;
+  }
+  const err2 = new v.ValitaError(res);
+  return { ok: false, error: getMessage(err2, value, schema, mode) };
+}
+function readonly(t) {
+  return t;
+}
+function readonlyObject(t) {
+  return v.object(t);
+}
+function readonlyArray(t) {
+  return v.array(t);
+}
+function readonlyRecord(t) {
+  return v.record(t);
+}
+var AbstractType = Object.getPrototypeOf(
+  Object.getPrototypeOf(v.string().optional())
+).constructor;
+function instanceOfAbstractType(obj) {
+  return obj instanceof AbstractType;
+}
+function deepPartial(s) {
+  const shape = {};
+  for (const [key, type] of Object.entries(s.shape)) {
+    if (type.name === "object") {
+      shape[key] = deepPartial(type).optional();
+    } else {
+      shape[key] = type.optional();
+    }
+  }
+  return v.object(shape);
+}
+
+// ../zero-protocol/src/ast.ts
+import { compareUTF8 } from "compare-utf8";
+
+// ../shared/src/arrays.ts
+function defined(arr) {
+  let i = arr.findIndex((x) => x === void 0);
+  if (i < 0) {
+    return arr;
+  }
+  const defined2 = arr.slice(0, i);
+  for (i++; i < arr.length; i++) {
+    const x = arr[i];
+    if (x !== void 0) {
+      defined2.push(x);
+    }
+  }
+  return defined2;
+}
+function areEqual(arr1, arr2) {
+  return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);
+}
+
+// ../shared/src/json-schema.ts
+import * as valita from "@badrap/valita";
+
+// ../shared/src/config.ts
+var isProd = process.env.NODE_ENV === "production";
+
+// ../shared/src/json.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  switch (typeof a) {
+    case "boolean":
+    case "number":
+    case "string":
+      return false;
+  }
+  a = a;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a === null || b === null) {
+    return false;
+  }
+  if (Array.isArray(b)) {
+    return false;
+  }
+  a = a;
+  b = b;
+  let aSize = 0;
+  for (const key in a) {
+    if (hasOwn(a, key)) {
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+      aSize++;
+    }
+  }
+  let bSize = 0;
+  for (const key in b) {
+    if (hasOwn(b, key)) {
+      bSize++;
+    }
+  }
+  return aSize === bSize;
+}
+function assertJSONValue(v2) {
+  if (isProd) {
+    return;
+  }
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return;
+    case "object":
+      if (v2 === null) {
+        return;
+      }
+      if (Array.isArray(v2)) {
+        return assertJSONArray(v2);
+      }
+      return assertObjectIsJSONObject(v2);
+  }
+  throwInvalidType(v2, "JSON value");
+}
+function assertJSONObject(v2) {
+  assertObject(v2);
+  assertObjectIsJSONObject(v2);
+}
+function assertObjectIsJSONObject(v2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      const value = v2[k];
+      if (value !== void 0) {
+        assertJSONValue(value);
+      }
+    }
+  }
+}
+function assertJSONArray(v2) {
+  for (const item of v2) {
+    assertJSONValue(item);
+  }
+}
+function isJSONValue(v2, path2) {
+  switch (typeof v2) {
+    case "boolean":
+    case "number":
+    case "string":
+      return true;
+    case "object":
+      if (v2 === null) {
+        return true;
+      }
+      if (Array.isArray(v2)) {
+        return isJSONArray(v2, path2);
+      }
+      return objectIsJSONObject(v2, path2);
+  }
+  return false;
+}
+function isJSONObject(v2, path2) {
+  if (typeof v2 !== "object" || v2 === null) {
+    return false;
+  }
+  return objectIsJSONObject(v2, path2);
+}
+function objectIsJSONObject(v2, path2) {
+  for (const k in v2) {
+    if (hasOwn(v2, k)) {
+      path2.push(k);
+      const value = v2[k];
+      if (value !== void 0 && !isJSONValue(value, path2)) {
+        return false;
+      }
+      path2.pop();
+    }
+  }
+  return true;
+}
+function isJSONArray(v2, path2) {
+  for (let i = 0; i < v2.length; i++) {
+    path2.push(i);
+    if (!isJSONValue(v2[i], path2)) {
+      return false;
+    }
+    path2.pop();
+  }
+  return true;
+}
+
+// ../shared/src/json-schema.ts
+var path = [];
+var jsonSchema = valita_exports.unknown().chain((v2) => {
+  if (isProd) {
+    return valita.ok(v2);
+  }
+  const rv = isJSONValue(v2, path) ? valita.ok(v2) : valita.err({
+    message: `Not a JSON value`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
+var jsonObjectSchema = valita_exports.unknown().chain((v2) => {
+  if (isProd) {
+    return valita.ok(v2);
+  }
+  const rv = isJSONObject(v2, path) ? valita.ok(v2) : valita.err({
+    message: `Not a JSON object`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
+
+// ../zero-protocol/src/data.ts
+var valueSchema = valita_exports.union(jsonSchema, valita_exports.undefined());
+var rowSchema = readonlyRecord(valueSchema);
+
+// ../zero-protocol/src/ast.ts
+var selectorSchema = valita_exports.string();
+var toStaticParam = Symbol();
+var orderingElementSchema = readonly(
+  valita_exports.tuple([selectorSchema, valita_exports.union(valita_exports.literal("asc"), valita_exports.literal("desc"))])
+);
+var orderingSchema = readonlyArray(orderingElementSchema);
+var primitiveSchema = valita_exports.union(
+  valita_exports.string(),
+  valita_exports.number(),
+  valita_exports.boolean(),
+  valita_exports.null()
+);
+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(">"),
+  valita_exports.literal("<="),
+  valita_exports.literal(">=")
+);
+var likeOpsSchema = valita_exports.union(
+  valita_exports.literal("LIKE"),
+  valita_exports.literal("NOT LIKE"),
+  valita_exports.literal("ILIKE"),
+  valita_exports.literal("NOT ILIKE")
+);
+var inOpsSchema = valita_exports.union(valita_exports.literal("IN"), valita_exports.literal("NOT IN"));
+var simpleOperatorSchema = valita_exports.union(
+  equalityOpsSchema,
+  orderOpsSchema,
+  likeOpsSchema,
+  inOpsSchema
+);
+var literalReferenceSchema = readonlyObject({
+  type: valita_exports.literal("literal"),
+  value: valita_exports.union(
+    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()))
+  )
+});
+var columnReferenceSchema = readonlyObject({
+  type: valita_exports.literal("column"),
+  name: valita_exports.string()
+});
+var parameterReferenceSchema = readonlyObject({
+  type: valita_exports.literal("static"),
+  // The "namespace" of the injected parameter.
+  // Write authorization will send the value of a row
+  // prior to the mutation being run (preMutationRow).
+  // Read and write authorization will both send the
+  // current authentication data (authData).
+  anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
+  field: valita_exports.union(valita_exports.string(), valita_exports.array(valita_exports.string()))
+});
+var conditionValueSchema = valita_exports.union(
+  literalReferenceSchema,
+  columnReferenceSchema,
+  parameterReferenceSchema
+);
+var simpleConditionSchema = readonlyObject({
+  type: valita_exports.literal("simple"),
+  op: simpleOperatorSchema,
+  left: conditionValueSchema,
+  right: valita_exports.union(parameterReferenceSchema, literalReferenceSchema)
+});
+var correlatedSubqueryConditionOperatorSchema = valita_exports.union(valita_exports.literal("EXISTS"), valita_exports.literal("NOT EXISTS"));
+var 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),
+  correlatedSubqueryConditionSchema
+);
+var conjunctionSchema = readonlyObject({
+  type: valita_exports.literal("and"),
+  conditions: readonlyArray(conditionSchema)
+});
+var disjunctionSchema = readonlyObject({
+  type: valita_exports.literal("or"),
+  conditions: readonlyArray(conditionSchema)
+});
+function mustCompoundKey(field) {
+  assert(Array.isArray(field) && field.length >= 1);
+  return field;
+}
+var compoundKeySchema = readonly(
+  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
+);
+var correlationSchema = readonlyObject({
+  parentField: compoundKeySchema,
+  childField: compoundKeySchema
+});
+var correlatedSubquerySchemaOmitSubquery = readonlyObject({
+  correlation: correlationSchema,
+  hidden: valita_exports.boolean().optional(),
+  system: valita_exports.union(valita_exports.literal("permissions"), valita_exports.literal("client")).optional()
+});
+var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
+  subquery: valita_exports.lazy(() => astSchema)
+});
+var astSchema = readonlyObject({
+  schema: valita_exports.string().optional(),
+  table: valita_exports.string(),
+  alias: valita_exports.string().optional(),
+  where: conditionSchema.optional(),
+  related: readonlyArray(correlatedSubquerySchema).optional(),
+  limit: valita_exports.number().optional(),
+  orderBy: orderingSchema.optional(),
+  start: valita_exports.object({
+    row: rowSchema,
+    exclusive: valita_exports.boolean()
+  }).optional()
+});
+function transformAST(ast, transform) {
+  const { tableName, columnName } = transform;
+  const colName = (c) => columnName(ast.table, c);
+  const key = (table, k) => {
+    const serverKey = k.map((col) => columnName(table, col));
+    return mustCompoundKey(serverKey);
+  };
+  const where = ast.where ? transform.where(ast.where) : void 0;
+  const transformed = {
+    schema: ast.schema,
+    table: tableName(ast.table),
+    alias: ast.alias,
+    where: where ? transformWhere(where, ast.table, transform) : void 0,
+    related: ast.related ? transform.related(
+      ast.related.map(
+        (r) => ({
+          correlation: {
+            parentField: key(ast.table, r.correlation.parentField),
+            childField: key(r.subquery.table, r.correlation.childField)
+          },
+          hidden: r.hidden,
+          subquery: transformAST(r.subquery, transform),
+          system: r.system
+        })
+      )
+    ) : void 0,
+    start: ast.start ? {
+      ...ast.start,
+      row: Object.fromEntries(
+        Object.entries(ast.start.row).map(([col, val]) => [
+          colName(col),
+          val
+        ])
+      )
+    } : void 0,
+    limit: ast.limit,
+    orderBy: ast.orderBy?.map(([col, dir]) => [colName(col), dir])
+  };
+  return transformed;
+}
+function transformWhere(where, table, transform) {
+  const { columnName } = transform;
+  const condValue = (c) => c.type !== "column" ? c : { ...c, name: columnName(table, c.name) };
+  const key = (table2, k) => {
+    const serverKey = k.map((col) => columnName(table2, col));
+    return mustCompoundKey(serverKey);
+  };
+  if (where.type === "simple") {
+    return { ...where, left: condValue(where.left) };
+  } else if (where.type === "correlatedSubquery") {
+    const { correlation, subquery } = where.related;
+    return {
+      ...where,
+      related: {
+        ...where.related,
+        correlation: {
+          parentField: key(table, correlation.parentField),
+          childField: key(subquery.table, correlation.childField)
+        },
+        subquery: transformAST(subquery, transform)
+      }
+    };
+  }
+  return {
+    type: where.type,
+    conditions: transform.conditions(
+      where.conditions.map((c) => transformWhere(c, table, transform))
+    )
+  };
+}
+var normalizeCache = /* @__PURE__ */ new WeakMap();
+var NORMALIZE_TRANSFORM = {
+  tableName: (t) => t,
+  columnName: (_, c) => c,
+  related: sortedRelated,
+  where: flattened,
+  conditions: (c) => c.sort(cmpCondition)
+};
+function normalizeAST(ast) {
+  let normalized = normalizeCache.get(ast);
+  if (!normalized) {
+    normalized = transformAST(ast, NORMALIZE_TRANSFORM);
+    normalizeCache.set(ast, normalized);
+  }
+  return normalized;
+}
+function mapAST(ast, mapper) {
+  return transformAST(ast, {
+    tableName: (table) => mapper.tableName(table),
+    columnName: (table, col) => mapper.columnName(table, col),
+    related: (r) => r,
+    where: (w) => w,
+    conditions: (c) => c
+  });
+}
+function mapCondition(cond, table, mapper) {
+  return transformWhere(cond, table, {
+    tableName: (table2) => mapper.tableName(table2),
+    columnName: (table2, col) => mapper.columnName(table2, col),
+    related: (r) => r,
+    where: (w) => w,
+    conditions: (c) => c
+  });
+}
+function sortedRelated(related) {
+  return related.sort(cmpRelated);
+}
+function cmpCondition(a, b) {
+  if (a.type === "simple") {
+    if (b.type !== "simple") {
+      return -1;
+    }
+    return compareValuePosition(a.left, b.left) || compareUTF8MaybeNull(a.op, b.op) || compareValuePosition(a.right, b.right);
+  }
+  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;
+  }
+  for (let l = 0, r = 0; l < a.conditions.length && r < b.conditions.length; l++, r++) {
+    const val2 = cmpCondition(a.conditions[l], b.conditions[r]);
+    if (val2 !== 0) {
+      return val2;
+    }
+  }
+  return a.conditions.length - b.conditions.length;
+}
+function compareValuePosition(a, b) {
+  if (a.type !== b.type) {
+    return compareUTF8(a.type, b.type);
+  }
+  switch (a.type) {
+    case "literal":
+      assert(b.type === "literal");
+      return compareUTF8(String(a.value), String(b.value));
+    case "column":
+      assert(b.type === "column");
+      return compareUTF8(a.name, b.name);
+    case "static":
+      throw new Error(
+        "Static parameters should be resolved before normalization"
+      );
+  }
+}
+function cmpRelated(a, b) {
+  return compareUTF8(must(a.subquery.alias), must(b.subquery.alias));
+}
+function flattened(cond) {
+  if (cond.type === "simple" || cond.type === "correlatedSubquery") {
+    return cond;
+  }
+  const conditions = defined(
+    cond.conditions.flatMap(
+      (c) => c.type === cond.type ? c.conditions.map((c2) => flattened(c2)) : flattened(c)
+    )
+  );
+  switch (conditions.length) {
+    case 0:
+      return void 0;
+    case 1:
+      return conditions[0];
+    default:
+      return {
+        type: cond.type,
+        conditions
+      };
+  }
+}
+function compareUTF8MaybeNull(a, b) {
+  if (a !== null && b !== null) {
+    return compareUTF8(a, b);
+  }
+  if (b !== null) {
+    return -1;
+  }
+  if (a !== null) {
+    return 1;
+  }
+  return 0;
+}
+
+// ../zero-schema/src/table-schema.ts
+function isOneHop(r) {
+  return r.length === 1;
+}
+function isTwoHop(r) {
+  return r.length === 2;
+}
+
+// ../zql/src/query/query-impl.ts
+import { resolver } from "@rocicorp/resolver";
+
+// ../shared/src/hash.ts
+import { xxHash32 } from "js-xxhash";
+var h64 = (s) => hash(s, 2);
+var h128 = (s) => hash(s, 4);
+function hash(str, words) {
+  let hash2 = 0n;
+  for (let i = 0; i < words; i++) {
+    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
+  }
+  return hash2;
+}
+
+// ../zero-protocol/src/ast-hash.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
+function hashOfAST(ast) {
+  const normalized = normalizeAST(ast);
+  const cached = hashCache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const hash2 = h64(JSON.stringify(normalized)).toString(36);
+  hashCache.set(normalized, hash2);
+  return hash2;
+}
+
+// ../zql/src/ivm/operator.ts
+var throwOutput = {
+  push(_change) {
+    throw new Error("Output not set");
+  }
+};
+
+// ../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;
+  #parentJoinKey;
+  #skipCache;
+  #output = throwOutput;
+  constructor(input, storage, relationshipName, parentJoinKey, 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";
+    this.#parentJoinKey = parentJoinKey;
+    this.#skipCache = areEqual(
+      parentJoinKey,
+      this.#input.getSchema().primaryKey
+    );
+  }
+  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)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#filter(node)) {
+        yield node;
+      } else {
+        drainStreams(node);
+      }
+      this.#delSize(node);
+    }
+  }
+  push(change) {
+    switch (change.type) {
+      // add, remove and edit cannot change the size of the
+      // this.#relationshipName relationship, so simply #pushWithFilter
+      case "add":
+      case "edit": {
+        this.#pushWithFilter(change);
+        return;
+      }
+      case "remove": {
+        const size = this.#getSize(change.node);
+        if (size === void 0) {
+          return;
+        }
+        this.#pushWithFilter(change, size);
+        this.#delSize(change.node);
+        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.node);
+            if (size !== void 0) {
+              size++;
+              this.#setCachedSize(change.node, size);
+              this.#setSize(change.node, size);
+            } else {
+              size = this.#fetchSize(change.node);
+            }
+            if (size === 1) {
+              if (this.#not) {
+                this.#output.push({
+                  type: "remove",
+                  node: {
+                    row: change.node.row,
+                    relationships: {
+                      ...change.node.relationships,
+                      [this.#relationshipName]: () => []
+                    }
+                  }
+                });
+              } else {
+                this.#output.push({
+                  type: "add",
+                  node: change.node
+                });
+              }
+            } else {
+              this.#pushWithFilter(change, size);
+            }
+            return;
+          }
+          case "remove": {
+            let size = this.#getSize(change.node);
+            if (size !== void 0) {
+              if (size === 0) {
+                return;
+              }
+              size--;
+              this.#setCachedSize(change.node, size);
+              this.#setSize(change.node, size);
+            } else {
+              size = this.#fetchSize(change.node);
+            }
+            if (size === 0) {
+              if (this.#not) {
+                this.#output.push({
+                  type: "add",
+                  node: change.node
+                });
+              } else {
+                this.#output.push({
+                  type: "remove",
+                  node: {
+                    row: change.node.row,
+                    relationships: {
+                      ...change.node.relationships,
+                      [this.#relationshipName]: () => [
+                        change.child.change.node
+                      ]
+                    }
+                  }
+                });
+              }
+            } else {
+              this.#pushWithFilter(change, size);
+            }
+            return;
+          }
+        }
+        return;
+      default:
+        unreachable(change);
+    }
+  }
+  /**
+   * Returns whether or not the node'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 streaming the node's
+   * relationship with this.#relationshipName (this computed size is also
+   * stored).
+   */
+  #filter(node, size) {
+    const exists = (size ?? this.#getOrFetchSize(node)) > 0;
+    return this.#not ? !exists : exists;
+  }
+  /**
+   * Pushes a change if this.#filter is true for its row.
+   */
+  #pushWithFilter(change, size) {
+    if (this.#filter(change.node, size)) {
+      this.#output.push(change);
+    }
+  }
+  #getSize(node) {
+    return this.#storage.get(this.#makeSizeStorageKey(node));
+  }
+  #setSize(node, size) {
+    this.#storage.set(this.#makeSizeStorageKey(node), size);
+  }
+  #setCachedSize(node, size) {
+    if (this.#skipCache) {
+      return;
+    }
+    this.#storage.set(this.#makeCacheStorageKey(node), size);
+  }
+  #getCachedSize(node) {
+    if (this.#skipCache) {
+      return void 0;
+    }
+    return this.#storage.get(this.#makeCacheStorageKey(node));
+  }
+  #delSize(node) {
+    this.#storage.del(this.#makeSizeStorageKey(node));
+    if (!this.#skipCache) {
+      const cacheKey = this.#makeCacheStorageKey(node);
+      if (first(this.#storage.scan({ prefix: `${cacheKey}/` })) === void 0) {
+        this.#storage.del(cacheKey);
+      }
+    }
+  }
+  #getOrFetchSize(node) {
+    const size = this.#getSize(node);
+    if (size !== void 0) {
+      return size;
+    }
+    return this.#fetchSize(node);
+  }
+  #fetchSize(node) {
+    const cachedSize = this.#getCachedSize(node);
+    if (cachedSize !== void 0) {
+      this.#setSize(node, cachedSize);
+      return cachedSize;
+    }
+    const relationship = node.relationships[this.#relationshipName];
+    assert(relationship);
+    let size = 0;
+    for (const _relatedNode of relationship()) {
+      size++;
+    }
+    this.#setCachedSize(node, size);
+    this.#setSize(node, size);
+    return size;
+  }
+  #makeCacheStorageKey(node) {
+    return `row/${JSON.stringify(
+      this.#getKeyValues(node, this.#parentJoinKey)
+    )}`;
+  }
+  #makeSizeStorageKey(node) {
+    return `row/${this.#skipCache ? "" : JSON.stringify(this.#getKeyValues(node, this.#parentJoinKey))}/${JSON.stringify(
+      this.#getKeyValues(node, this.#input.getSchema().primaryKey)
+    )}`;
+  }
+  #getKeyValues(node, def) {
+    const values = [];
+    for (const key of def) {
+      values.push(normalizeUndefined(node.row[key]));
+    }
+    return values;
+  }
+};
+
+// ../shared/src/iterables.ts
+function* joinIterables(...iters) {
+  for (const iter of iters) {
+    yield* iter;
+  }
+}
+function* filterIter(iter, p) {
+  let index = 0;
+  for (const t of iter) {
+    if (p(t, index++)) {
+      yield t;
+    }
+  }
+}
+function* mapIter(iter, f) {
+  let index = 0;
+  for (const t of iter) {
+    yield f(t, index++);
+  }
+}
+function first2(stream) {
+  const it = stream[Symbol.iterator]();
+  const { value } = it.next();
+  it.return?.();
+  return value;
+}
+var IterWrapper = class _IterWrapper {
+  iter;
+  constructor(iter) {
+    this.iter = iter;
+  }
+  [Symbol.iterator]() {
+    return this.iter[Symbol.iterator]();
+  }
+  map(f) {
+    return new _IterWrapper(mapIter(this.iter, f));
+  }
+  filter(p) {
+    return new _IterWrapper(filterIter(this.iter, p));
+  }
+};
+function wrapIterable(iter) {
+  return new IterWrapper(iter);
+}
+function* mergeIterables(iterables, comparator, distinct = false) {
+  const iterators = iterables.map((i) => i[Symbol.iterator]());
+  try {
+    const current = iterators.map((i) => i.next());
+    let lastYielded;
+    while (current.some((c) => !c.done)) {
+      const min = current.reduce(
+        (acc, c, i) => {
+          if (c.done) {
+            return acc;
+          }
+          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
+            return [c.value, i];
+          }
+          return acc;
+        },
+        void 0
+      );
+      assert(min !== void 0, "min is undefined");
+      current[min[1]] = iterators[min[1]].next();
+      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
+        continue;
+      }
+      lastYielded = min[0];
+      yield min[0];
+    }
+  } finally {
+    for (const it of iterators) {
+      it.return?.();
+    }
+  }
+}
+
+// ../zql/src/ivm/fan-in.ts
+var FanIn = class {
+  #inputs;
+  #fanOut;
+  #schema;
+  #output = throwOutput;
+  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));
+  }
+  cleanup(req) {
+    return this.#fetchOrCleanup((input) => input.cleanup(req));
+  }
+  *#fetchOrCleanup(streamProvider) {
+    const iterables = this.#inputs.map((input) => streamProvider(input));
+    yield* mergeIterables(
+      iterables,
+      (l, r) => must(this.#schema).compareRows(l.row, r.row),
+      true
+    );
+  }
+  push(change) {
+    this.#fanOut.onFanInReceivedPush();
+    this.#output.push(change);
+  }
+};
+
+// ../zql/src/ivm/fan-out.ts
+var FanOut = class {
+  #input;
+  #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 = false;
+  #destroyCount = 0;
+  constructor(input) {
+    this.#input = input;
+    input.setOutput(this);
+  }
+  setOutput(output) {
+    this.#outputs.push(output);
+  }
+  destroy() {
+    if (this.#destroyCount < this.#outputs.length) {
+      if (this.#destroyCount === 0) {
+        this.#input.destroy();
+      }
+      ++this.#destroyCount;
+    } else {
+      throw new Error("FanOut already destroyed once for each output");
+    }
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  fetch(req) {
+    return this.#input.fetch(req);
+  }
+  cleanup(req) {
+    return this.#input.cleanup(req);
+  }
+  onFanInReceivedPush() {
+    this.#fanInReceivedPush = true;
+  }
+  push(change) {
+    this.#fanInReceivedPush = false;
+    for (const out of this.#outputs) {
+      out.push(change);
+      if (this.#fanInReceivedPush) {
+        return;
+      }
+    }
+  }
+};
+
+// ../zql/src/ivm/maybe-split-and-push-edit-change.ts
+function maybeSplitAndPushEditChange(change, predicate, output) {
+  const oldWasPresent = predicate(change.oldNode.row);
+  const newIsPresent = predicate(change.node.row);
+  if (oldWasPresent && newIsPresent) {
+    output.push(change);
+  } else if (oldWasPresent && !newIsPresent) {
+    output.push({
+      type: "remove",
+      node: change.oldNode
+    });
+  } else if (!oldWasPresent && newIsPresent) {
+    output.push({
+      type: "add",
+      node: change.node
+    });
+  }
+}
+
+// ../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.node.row)) {
+        output.push(change);
+      }
+      break;
+    case "edit":
+      maybeSplitAndPushEditChange(change, predicate, output);
+      break;
+    default:
+      unreachable(change);
+  }
+}
+
+// ../zql/src/ivm/filter.ts
+var Filter = class {
+  #input;
+  #predicate;
+  #output = throwOutput;
+  constructor(input, predicate) {
+    this.#input = input;
+    this.#predicate = predicate;
+    input.setOutput(this);
+  }
+  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.#predicate(node.row)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#predicate(node.row)) {
+        yield node;
+      } else {
+        drainStreams(node);
+      }
+    }
+  }
+  push(change) {
+    filterPush(change, this.#output, this.#predicate);
+  }
+};
+
+// ../zql/src/ivm/join.ts
+var Join = class {
+  #parent;
+  #child;
+  #storage;
+  #parentKey;
+  #childKey;
+  #relationshipName;
+  #schema;
+  #output = throwOutput;
+  constructor({
+    parent,
+    child,
+    storage,
+    parentKey,
+    childKey,
+    relationshipName,
+    hidden,
+    system
+  }) {
+    assert(parent !== child, "Parent and child must be different operators");
+    assert(
+      parentKey.length === childKey.length,
+      "The parentKey and childKey keys must have same length"
+    );
+    this.#parent = parent;
+    this.#child = child;
+    this.#storage = storage;
+    this.#parentKey = parentKey;
+    this.#childKey = childKey;
+    this.#relationshipName = relationshipName;
+    const parentSchema = parent.getSchema();
+    const childSchema = child.getSchema();
+    this.#schema = {
+      ...parentSchema,
+      relationships: {
+        ...parentSchema.relationships,
+        [relationshipName]: {
+          ...childSchema,
+          isHidden: hidden,
+          system
+        }
+      }
+    };
+    parent.setOutput({
+      push: (change) => this.#pushParent(change)
+    });
+    child.setOutput({
+      push: (change) => this.#pushChild(change)
+    });
+  }
+  destroy() {
+    this.#parent.destroy();
+    this.#child.destroy();
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  getSchema() {
+    return this.#schema;
+  }
+  *fetch(req) {
+    for (const parentNode of this.#parent.fetch(req)) {
+      yield this.#processParentNode(
+        parentNode.row,
+        parentNode.relationships,
+        "fetch"
+      );
+    }
+  }
+  *cleanup(req) {
+    for (const parentNode of this.#parent.cleanup(req)) {
+      yield this.#processParentNode(
+        parentNode.row,
+        parentNode.relationships,
+        "cleanup"
+      );
+    }
+  }
+  #pushParent(change) {
+    switch (change.type) {
+      case "add":
+        this.#output.push({
+          type: "add",
+          node: this.#processParentNode(
+            change.node.row,
+            change.node.relationships,
+            "fetch"
+          )
+        });
+        break;
+      case "remove":
+        this.#output.push({
+          type: "remove",
+          node: this.#processParentNode(
+            change.node.row,
+            change.node.relationships,
+            "cleanup"
+          )
+        });
+        break;
+      case "child":
+        this.#output.push({
+          type: "child",
+          node: this.#processParentNode(
+            change.node.row,
+            change.node.relationships,
+            "fetch"
+          ),
+          child: change.child
+        });
+        break;
+      case "edit": {
+        if (rowEqualsForCompoundKey(
+          change.oldNode.row,
+          change.node.row,
+          this.#parentKey
+        )) {
+          this.#output.push({
+            type: "edit",
+            oldNode: this.#processParentNode(
+              change.oldNode.row,
+              change.oldNode.relationships,
+              "cleanup"
+            ),
+            node: this.#processParentNode(
+              change.node.row,
+              change.node.relationships,
+              "fetch"
+            )
+          });
+        } else {
+          this.#pushParent({
+            type: "remove",
+            node: change.oldNode
+          });
+          this.#pushParent({
+            type: "add",
+            node: change.node
+          });
+        }
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+  #pushChild(change) {
+    const pushChildChange = (childRow, change2) => {
+      const parentNodes = this.#parent.fetch({
+        constraint: Object.fromEntries(
+          this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
+        )
+      });
+      for (const parentNode of parentNodes) {
+        const childChange = {
+          type: "child",
+          node: this.#processParentNode(
+            parentNode.row,
+            parentNode.relationships,
+            "fetch"
+          ),
+          child: {
+            relationshipName: this.#relationshipName,
+            change: change2
+          }
+        };
+        this.#output.push(childChange);
+      }
+    };
+    switch (change.type) {
+      case "add":
+      case "remove":
+        pushChildChange(change.node.row, change);
+        break;
+      case "child":
+        pushChildChange(change.node.row, change);
+        break;
+      case "edit": {
+        const childRow = change.node.row;
+        const oldChildRow = change.oldNode.row;
+        if (rowEqualsForCompoundKey(oldChildRow, childRow, this.#childKey)) {
+          pushChildChange(childRow, change);
+        } else {
+          pushChildChange(oldChildRow, {
+            type: "remove",
+            node: change.oldNode
+          });
+          pushChildChange(childRow, {
+            type: "add",
+            node: change.node
+          });
+        }
+        break;
+      }
+      default:
+        unreachable(change);
+    }
+  }
+  #processParentNode(parentNodeRow, parentNodeRelations, mode) {
+    let method = mode;
+    let storageUpdated = false;
+    const childStream = () => {
+      if (!storageUpdated) {
+        if (mode === "cleanup") {
+          this.#storage.del(
+            makeStorageKey(
+              this.#parentKey,
+              this.#parent.getSchema().primaryKey,
+              parentNodeRow
+            )
+          );
+          const empty = [
+            ...take(
+              this.#storage.scan({
+                prefix: makeStorageKeyPrefix(parentNodeRow, this.#parentKey)
+              }),
+              1
+            )
+          ].length === 0;
+          method = empty ? "cleanup" : "fetch";
+        }
+        storageUpdated = true;
+        if (mode === "fetch") {
+          this.#storage.set(
+            makeStorageKey(
+              this.#parentKey,
+              this.#parent.getSchema().primaryKey,
+              parentNodeRow
+            ),
+            true
+          );
+        }
+      }
+      return this.#child[method]({
+        constraint: Object.fromEntries(
+          this.#childKey.map((key, i) => [
+            key,
+            parentNodeRow[this.#parentKey[i]]
+          ])
+        )
+      });
+    };
+    return {
+      row: parentNodeRow,
+      relationships: {
+        ...parentNodeRelations,
+        [this.#relationshipName]: childStream
+      }
+    };
+  }
+};
+function makeStorageKeyForValues(values) {
+  const json = JSON.stringify(["pKeySet", ...values]);
+  return json.substring(1, json.length - 1) + ",";
+}
+function makeStorageKeyPrefix(row, key) {
+  return makeStorageKeyForValues(key.map((k) => row[k]));
+}
+function makeStorageKey(key, primaryKey, row) {
+  const values = key.map((k) => row[k]);
+  for (const key2 of primaryKey) {
+    values.push(row[key2]);
+  }
+  return makeStorageKeyForValues(values);
+}
+function rowEqualsForCompoundKey(a, b, key) {
+  for (let i = 0; i < key.length; i++) {
+    if (!valuesEqual(a[key[i]], b[key[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../zql/src/ivm/skip.ts
+var Skip = class {
+  #input;
+  #bound;
+  #comparator;
+  #output = throwOutput;
+  constructor(input, bound) {
+    this.#input = input;
+    this.#bound = bound;
+    this.#comparator = input.getSchema().compareRows;
+    input.setOutput(this);
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  fetch(req) {
+    return this.#fetchOrCleanup("fetch", req);
+  }
+  cleanup(req) {
+    return this.#fetchOrCleanup("fetch", req);
+  }
+  *#fetchOrCleanup(method, req) {
+    const start = this.#getStart(req);
+    if (start === "empty") {
+      return;
+    }
+    const nodes = this.#input[method]({ ...req, start });
+    if (!req.reverse) {
+      yield* nodes;
+      return;
+    }
+    for (const node of nodes) {
+      if (!this.#shouldBePresent(node.row)) {
+        return;
+      }
+      yield node;
+    }
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  #shouldBePresent(row) {
+    const cmp2 = this.#comparator(this.#bound.row, row);
+    return cmp2 < 0 || cmp2 === 0 && !this.#bound.exclusive;
+  }
+  push(change) {
+    const shouldBePresent = (row) => this.#shouldBePresent(row);
+    if (change.type === "edit") {
+      maybeSplitAndPushEditChange(change, shouldBePresent, this.#output);
+      return;
+    }
+    change;
+    if (shouldBePresent(change.node.row)) {
+      this.#output.push(change);
+    }
+  }
+  #getStart(req) {
+    const boundStart = {
+      row: this.#bound.row,
+      basis: this.#bound.exclusive ? "after" : "at"
+    };
+    if (!req.start) {
+      if (req.reverse) {
+        return void 0;
+      }
+      return boundStart;
+    }
+    const cmp2 = this.#comparator(this.#bound.row, req.start.row);
+    if (!req.reverse) {
+      if (cmp2 > 0) {
+        return boundStart;
+      }
+      if (cmp2 === 0) {
+        if (this.#bound.exclusive || req.start.basis === "after") {
+          return {
+            row: this.#bound.row,
+            basis: "after"
+          };
+        }
+        return boundStart;
+      }
+      return req.start;
+    }
+    req.reverse;
+    if (cmp2 > 0) {
+      return "empty";
+    }
+    if (cmp2 === 0) {
+      if (!this.#bound.exclusive && req.start.basis === "at") {
+        return boundStart;
+      }
+      return "empty";
+    }
+    return req.start;
+  }
+};
+
+// ../zql/src/ivm/take.ts
+var MAX_BOUND_KEY = "maxBound";
+var Take = class {
+  #input;
+  #storage;
+  #limit;
+  #partitionKey;
+  #partitionKeyComparator;
+  #output = throwOutput;
+  constructor(input, storage, limit, partitionKey) {
+    assert(limit >= 0);
+    assertOrderingIncludesPK(
+      input.getSchema().sort,
+      input.getSchema().primaryKey
+    );
+    input.setOutput(this);
+    this.#input = input;
+    this.#storage = storage;
+    this.#limit = limit;
+    this.#partitionKey = partitionKey;
+    this.#partitionKeyComparator = partitionKey && makePartitionKeyComparator(partitionKey);
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  *fetch(req) {
+    if (!this.#partitionKey || req.constraint && constraintMatchesPartitionKey(req.constraint, this.#partitionKey)) {
+      const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+      const takeState = this.#storage.get(takeStateKey);
+      if (!takeState) {
+        yield* this.#initialFetch(req);
+        return;
+      }
+      if (takeState.bound === void 0) {
+        return;
+      }
+      for (const inputNode of this.#input.fetch(req)) {
+        if (this.getSchema().compareRows(takeState.bound, inputNode.row) < 0) {
+          return;
+        }
+        yield inputNode;
+      }
+      return;
+    }
+    const maxBound = this.#storage.get(MAX_BOUND_KEY);
+    if (maxBound === void 0) {
+      return;
+    }
+    for (const inputNode of this.#input.fetch(req)) {
+      if (this.getSchema().compareRows(inputNode.row, maxBound) > 0) {
+        return;
+      }
+      const takeStateKey = getTakeStateKey(this.#partitionKey, inputNode.row);
+      const takeState = this.#storage.get(takeStateKey);
+      if (takeState?.bound !== void 0 && this.getSchema().compareRows(takeState.bound, inputNode.row) >= 0) {
+        yield inputNode;
+      }
+    }
+  }
+  *#initialFetch(req) {
+    assert(req.start === void 0);
+    assert(!req.reverse);
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
+    if (this.#limit === 0) {
+      return;
+    }
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+    assert(this.#storage.get(takeStateKey) === void 0);
+    let size = 0;
+    let bound;
+    let downstreamEarlyReturn = true;
+    let exceptionThrown = false;
+    try {
+      for (const inputNode of this.#input.fetch(req)) {
+        yield inputNode;
+        bound = inputNode.row;
+        size++;
+        if (size === this.#limit) {
+          break;
+        }
+      }
+      downstreamEarlyReturn = false;
+    } catch (e) {
+      exceptionThrown = true;
+      throw e;
+    } finally {
+      if (!exceptionThrown) {
+        this.#setTakeState(
+          takeStateKey,
+          size,
+          bound,
+          this.#storage.get(MAX_BOUND_KEY)
+        );
+        assert(
+          !downstreamEarlyReturn,
+          "Unexpected early return prevented full hydration"
+        );
+      }
+    }
+  }
+  *cleanup(req) {
+    assert(req.start === void 0);
+    assert(constraintMatchesPartitionKey(req.constraint, this.#partitionKey));
+    const takeStateKey = getTakeStateKey(this.#partitionKey, req.constraint);
+    this.#storage.del(takeStateKey);
+    let size = 0;
+    for (const inputNode of this.#input.cleanup(req)) {
+      if (size === this.#limit) {
+        return;
+      }
+      size++;
+      yield inputNode;
+    }
+  }
+  #getStateAndConstraint(row) {
+    const takeStateKey = getTakeStateKey(this.#partitionKey, row);
+    const takeState = this.#storage.get(takeStateKey);
+    let maxBound;
+    let constraint;
+    if (takeState) {
+      maxBound = this.#storage.get(MAX_BOUND_KEY);
+      constraint = this.#partitionKey && Object.fromEntries(
+        this.#partitionKey.map((key) => [key, row[key]])
+      );
+    }
+    return { takeState, takeStateKey, maxBound, constraint };
+  }
+  push(change) {
+    if (change.type === "edit") {
+      this.#pushEditChange(change);
+      return;
+    }
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.node.row);
+    if (!takeState) {
+      return;
+    }
+    const { compareRows } = this.getSchema();
+    if (change.type === "add") {
+      if (takeState.size < this.#limit) {
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size + 1,
+          takeState.bound === void 0 || compareRows(takeState.bound, change.node.row) < 0 ? change.node.row : takeState.bound,
+          maxBound
+        );
+        this.#output.push(change);
+        return;
+      }
+      if (takeState.bound === void 0 || compareRows(change.node.row, takeState.bound) >= 0) {
+        return;
+      }
+      let beforeBoundNode;
+      let boundNode;
+      if (this.#limit === 1) {
+        boundNode = must(
+          first(
+            this.#input.fetch({
+              start: {
+                row: takeState.bound,
+                basis: "at"
+              },
+              constraint
+            })
+          )
+        );
+      } else {
+        [boundNode, beforeBoundNode] = take(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "at"
+            },
+            constraint,
+            reverse: true
+          }),
+          2
+        );
+      }
+      const removeChange = {
+        type: "remove",
+        node: boundNode
+      };
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        beforeBoundNode === void 0 || compareRows(change.node.row, beforeBoundNode.row) > 0 ? change.node.row : beforeBoundNode.row,
+        maxBound
+      );
+      this.#output.push(removeChange);
+      this.#output.push(change);
+    } else if (change.type === "remove") {
+      if (takeState.bound === void 0) {
+        return;
+      }
+      const compToBound = compareRows(change.node.row, takeState.bound);
+      if (compToBound > 0) {
+        return;
+      }
+      const [beforeBoundNode] = take(
+        this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "after"
+          },
+          constraint,
+          reverse: true
+        }),
+        1
+      );
+      let newBound;
+      if (beforeBoundNode) {
+        const push = compareRows(beforeBoundNode.row, takeState.bound) > 0;
+        newBound = {
+          node: beforeBoundNode,
+          push
+        };
+      }
+      if (!newBound?.push) {
+        for (const node of this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "at"
+          },
+          constraint
+        })) {
+          const push = compareRows(node.row, takeState.bound) > 0;
+          newBound = {
+            node,
+            push
+          };
+          if (push) {
+            break;
+          }
+        }
+      }
+      if (newBound?.push) {
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size,
+          newBound.node.row,
+          maxBound
+        );
+        this.#output.push(change);
+        this.#output.push({
+          type: "add",
+          node: newBound.node
+        });
+        return;
+      }
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size - 1,
+        newBound?.node.row,
+        maxBound
+      );
+      this.#output.push(change);
+    } else if (change.type === "child") {
+      if (takeState.bound && compareRows(change.node.row, takeState.bound) <= 0) {
+        this.#output.push(change);
+      }
+    }
+  }
+  #pushEditChange(change) {
+    if (this.#partitionKeyComparator && this.#partitionKeyComparator(change.oldNode.row, change.node.row) !== 0) {
+      this.push({
+        type: "remove",
+        node: change.oldNode
+      });
+      this.push({
+        type: "add",
+        node: change.node
+      });
+      return;
+    }
+    const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(change.oldNode.row);
+    if (!takeState) {
+      return;
+    }
+    assert(takeState.bound, "Bound should be set");
+    const { compareRows } = this.getSchema();
+    const oldCmp = compareRows(change.oldNode.row, takeState.bound);
+    const newCmp = compareRows(change.node.row, takeState.bound);
+    const replaceBoundAndForwardChange = () => {
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        change.node.row,
+        maxBound
+      );
+      this.#output.push(change);
+    };
+    if (oldCmp === 0) {
+      if (newCmp === 0) {
+        this.#output.push(change);
+        return;
+      }
+      if (newCmp < 0) {
+        if (this.#limit === 1) {
+          replaceBoundAndForwardChange();
+          return;
+        }
+        const beforeBoundNode = must(
+          first(
+            this.#input.fetch({
+              start: {
+                row: takeState.bound,
+                basis: "after"
+              },
+              constraint,
+              reverse: true
+            })
+          )
+        );
+        this.#setTakeState(
+          takeStateKey,
+          takeState.size,
+          beforeBoundNode.row,
+          maxBound
+        );
+        this.#output.push(change);
+        return;
+      }
+      assert(newCmp > 0);
+      const newBoundNode = must(
+        first(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "at"
+            },
+            constraint
+          })
+        )
+      );
+      if (compareRows(newBoundNode.row, change.node.row) === 0) {
+        replaceBoundAndForwardChange();
+        return;
+      }
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        newBoundNode.row,
+        maxBound
+      );
+      this.#output.push({
+        type: "remove",
+        node: change.oldNode
+      });
+      this.#output.push({
+        type: "add",
+        node: newBoundNode
+      });
+      return;
+    }
+    if (oldCmp > 0) {
+      assert(newCmp !== 0, "Invalid state. Row has duplicate primary key");
+      if (newCmp > 0) {
+        return;
+      }
+      assert(newCmp < 0);
+      const [oldBoundNode, newBoundNode] = take(
+        this.#input.fetch({
+          start: {
+            row: takeState.bound,
+            basis: "at"
+          },
+          constraint,
+          reverse: true
+        }),
+        2
+      );
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        newBoundNode.row,
+        maxBound
+      );
+      this.#output.push({
+        type: "remove",
+        node: oldBoundNode
+      });
+      this.#output.push({
+        type: "add",
+        node: change.node
+      });
+      return;
+    }
+    if (oldCmp < 0) {
+      assert(newCmp !== 0, "Invalid state. Row has duplicate primary key");
+      if (newCmp < 0) {
+        this.#output.push(change);
+        return;
+      }
+      assert(newCmp > 0);
+      const afterBoundNode = must(
+        first(
+          this.#input.fetch({
+            start: {
+              row: takeState.bound,
+              basis: "after"
+            },
+            constraint
+          })
+        )
+      );
+      if (compareRows(afterBoundNode.row, change.node.row) === 0) {
+        replaceBoundAndForwardChange();
+        return;
+      }
+      this.#setTakeState(
+        takeStateKey,
+        takeState.size,
+        afterBoundNode.row,
+        maxBound
+      );
+      this.#output.push({
+        type: "remove",
+        node: change.oldNode
+      });
+      this.#output.push({
+        type: "add",
+        node: afterBoundNode
+      });
+      return;
+    }
+    unreachable();
+  }
+  #setTakeState(takeStateKey, size, bound, maxBound) {
+    this.#storage.set(takeStateKey, {
+      size,
+      bound
+    });
+    if (bound !== void 0 && (maxBound === void 0 || this.getSchema().compareRows(bound, maxBound) > 0)) {
+      this.#storage.set(MAX_BOUND_KEY, bound);
+    }
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+};
+function getTakeStateKey(partitionKey, rowOrConstraint) {
+  const partitionValues = [];
+  if (partitionKey && rowOrConstraint) {
+    for (const key of partitionKey) {
+      partitionValues.push(rowOrConstraint[key]);
+    }
+  }
+  return JSON.stringify(["take", ...partitionValues]);
+}
+function constraintMatchesPartitionKey(constraint, partitionKey) {
+  if (constraint === void 0 || partitionKey === void 0) {
+    return constraint === partitionKey;
+  }
+  if (partitionKey.length !== Object.keys(constraint).length) {
+    return false;
+  }
+  for (const key of partitionKey) {
+    if (!hasOwn(constraint, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function makePartitionKeyComparator(partitionKey) {
+  return (a, b) => {
+    for (const key of partitionKey) {
+      const cmp2 = compareValues(a[key], b[key]);
+      if (cmp2 !== 0) {
+        return cmp2;
+      }
+    }
+    return 0;
+  };
+}
+
+// ../zql/src/builder/like.ts
+function getLikePredicate(pattern, flags) {
+  const op = getLikeOp(String(pattern), flags);
+  return (lhs) => {
+    assertString(lhs);
+    return op(String(lhs));
+  };
+}
+function getLikeOp(pattern, flags) {
+  if (!/_|%|\\/.test(pattern)) {
+    if (flags === "i") {
+      const rhsLower = pattern.toLowerCase();
+      return (lhs) => lhs.toLowerCase() === rhsLower;
+    }
+    return (lhs) => lhs === pattern;
+  }
+  const re = patternToRegExp(pattern, flags);
+  return (lhs) => re.test(lhs);
+}
+var specialCharsRe = /[$()*+.?[\]\\^{|}]/;
+function patternToRegExp(source, flags = "") {
+  let pattern = "^";
+  for (let i = 0; i < source.length; i++) {
+    let c = source[i];
+    switch (c) {
+      case "%":
+        pattern += ".*";
+        break;
+      case "_":
+        pattern += ".";
+        break;
+      // @ts-expect-error fallthrough
+      case "\\":
+        if (i === source.length - 1) {
+          throw new Error("LIKE pattern must not end with escape character");
+        }
+        i++;
+        c = source[i];
+      // fall through
+      default:
+        if (specialCharsRe.test(c)) {
+          pattern += "\\";
+        }
+        pattern += c;
+        break;
+    }
+  }
+  return new RegExp(pattern + "$", flags + "m");
+}
+
+// ../zql/src/builder/filter.ts
+function createPredicate(condition) {
+  if (condition.type !== "simple") {
+    const predicates = condition.conditions.map((c) => createPredicate(c));
+    return condition.type === "and" ? (row) => {
+      for (const predicate of predicates) {
+        if (!predicate(row)) {
+          return false;
+        }
+      }
+      return true;
+    } : (row) => {
+      for (const predicate of predicates) {
+        if (predicate(row)) {
+          return true;
+        }
+      }
+      return false;
+    };
+  }
+  const { left } = condition;
+  const { right } = condition;
+  assert(
+    right.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
+  assert(
+    left.type !== "static",
+    "static values should be resolved before creating predicates"
+  );
+  switch (condition.op) {
+    case "IS":
+    case "IS NOT": {
+      const impl2 = createIsPredicate(right.value, condition.op);
+      if (left.type === "literal") {
+        const result = impl2(left.value);
+        return () => result;
+      }
+      return (row) => impl2(row[left.name]);
+    }
+  }
+  if (right.value === null || right.value === void 0) {
+    return (_row) => false;
+  }
+  const impl = createPredicateImpl(right.value, condition.op);
+  if (left.type === "literal") {
+    if (left.value === null || left.value === void 0) {
+      return (_row) => false;
+    }
+    const result = impl(left.value);
+    return () => result;
+  }
+  return (row) => {
+    const lhs = row[left.name];
+    if (lhs === null || lhs === void 0) {
+      return false;
+    }
+    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 "=":
+      return (lhs) => lhs === rhs;
+    case "!=":
+      return (lhs) => lhs !== rhs;
+    case "<":
+      return (lhs) => lhs < rhs;
+    case "<=":
+      return (lhs) => lhs <= rhs;
+    case ">":
+      return (lhs) => lhs > rhs;
+    case ">=":
+      return (lhs) => lhs >= rhs;
+    case "LIKE":
+      return getLikePredicate(rhs, "");
+    case "NOT LIKE":
+      return not(getLikePredicate(rhs, ""));
+    case "ILIKE":
+      return getLikePredicate(rhs, "i");
+    case "NOT ILIKE":
+      return not(getLikePredicate(rhs, "i"));
+    case "IN": {
+      assert(Array.isArray(rhs));
+      const set = new Set(rhs);
+      return (lhs) => set.has(lhs);
+    }
+    case "NOT IN": {
+      assert(Array.isArray(rhs));
+      const set = new Set(rhs);
+      return (lhs) => !set.has(lhs);
+    }
+    default:
+      operator;
+      throw new Error(`Unexpected operator: ${operator}`);
+  }
+}
+function not(f) {
+  return (lhs) => !f(lhs);
+}
+function transformFilters(filters) {
+  if (!filters) {
+    return { filters: void 0, conditionsRemoved: false };
+  }
+  switch (filters.type) {
+    case "simple":
+      return { filters, conditionsRemoved: false };
+    case "correlatedSubquery":
+      return { filters: void 0, conditionsRemoved: true };
+    case "and": {
+      const transformedConditions = [];
+      for (const cond of filters.conditions) {
+        assert(cond.type === "simple" || cond.type === "correlatedSubquery");
+        if (cond.type === "simple") {
+          transformedConditions.push(cond);
+        }
+      }
+      const conditionsRemoved = transformedConditions.length !== filters.conditions.length;
+      if (transformedConditions.length === 0) {
+        return { filters: void 0, conditionsRemoved };
+      }
+      if (transformedConditions.length === 1) {
+        return {
+          filters: transformedConditions[0],
+          conditionsRemoved
+        };
+      }
+      return {
+        filters: {
+          type: "and",
+          conditions: transformedConditions
+        },
+        conditionsRemoved
+      };
+    }
+    case "or": {
+      const transformedConditions = [];
+      let conditionsRemoved = false;
+      for (const cond of filters.conditions) {
+        assert(cond.type !== "or");
+        const transformed = transformFilters(cond);
+        if (transformed.filters === void 0) {
+          return { filters: void 0, conditionsRemoved: true };
+        }
+        conditionsRemoved = conditionsRemoved || transformed.conditionsRemoved;
+        transformedConditions.push(transformed.filters);
+      }
+      return {
+        filters: { type: "or", conditions: transformedConditions },
+        conditionsRemoved
+      };
+    }
+    default:
+      unreachable(filters);
+  }
+}
+
+// ../zql/src/builder/builder.ts
+function buildPipeline(ast, delegate) {
+  return buildPipelineInternal(ast, delegate);
+}
+function buildPipelineInternal(ast, delegate, partitionKey) {
+  const source = delegate.getSource(ast.table);
+  if (!source) {
+    throw new Error(`Source not found: ${ast.table}`);
+  }
+  const conn = source.connect(must(ast.orderBy), ast.where);
+  let end = conn;
+  const { fullyAppliedFilters } = conn;
+  ast = uniquifyCorrelatedSubqueryConditionAliases(ast);
+  if (ast.start) {
+    end = new Skip(end, ast.start);
+  }
+  for (const csq of gatherCorrelatedSubqueryQueriesFromCondition(ast.where)) {
+    end = applyCorrelatedSubQuery(csq, delegate, end);
+  }
+  if (ast.where && !fullyAppliedFilters) {
+    end = applyWhere(end, ast.where, delegate);
+  }
+  if (ast.limit) {
+    end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
+  }
+  if (ast.related) {
+    for (const csq of ast.related) {
+      end = applyCorrelatedSubQuery(csq, delegate, end);
+    }
+  }
+  return end;
+}
+function applyWhere(input, condition, delegate) {
+  switch (condition.type) {
+    case "and":
+      return applyAnd(input, condition, delegate);
+    case "or":
+      return applyOr(input, condition, delegate);
+    case "correlatedSubquery":
+      return applyCorrelatedSubqueryCondition(input, condition, delegate);
+    case "simple":
+      return applySimpleCondition(input, condition);
+  }
+}
+function applyAnd(input, condition, delegate) {
+  for (const subCondition of condition.conditions) {
+    input = applyWhere(input, subCondition, delegate);
+  }
+  return input;
+}
+function applyOr(input, condition, delegate) {
+  const [subqueryConditions, otherConditions] = groupSubqueryConditions(condition);
+  if (subqueryConditions.length === 0) {
+    return new Filter(
+      input,
+      createPredicate({
+        type: "or",
+        conditions: otherConditions
+      })
+    );
+  }
+  const fanOut = new FanOut(input);
+  const branches = subqueryConditions.map(
+    (subCondition) => applyWhere(fanOut, subCondition, delegate)
+  );
+  if (otherConditions.length > 0) {
+    branches.push(
+      new Filter(
+        fanOut,
+        createPredicate({
+          type: "or",
+          conditions: otherConditions
+        })
+      )
+    );
+  }
+  return new FanIn(fanOut, branches);
+}
+function groupSubqueryConditions(condition) {
+  const partitioned = [[], []];
+  for (const subCondition of condition.conditions) {
+    if (isNotAndDoesNotContainSubquery(subCondition)) {
+      partitioned[1].push(subCondition);
+    } else {
+      partitioned[0].push(subCondition);
+    }
+  }
+  return partitioned;
+}
+function isNotAndDoesNotContainSubquery(condition) {
+  if (condition.type === "correlatedSubquery") {
+    return false;
+  }
+  if (condition.type === "and") {
+    return condition.conditions.every(isNotAndDoesNotContainSubquery);
+  }
+  assert(condition.type !== "or", "where conditions are expected to be in DNF");
+  return true;
+}
+function applySimpleCondition(input, condition) {
+  return new Filter(input, createPredicate(condition));
+}
+function applyCorrelatedSubQuery(sq, delegate, end) {
+  assert(sq.subquery.alias, "Subquery must have an alias");
+  const child = buildPipelineInternal(
+    sq.subquery,
+    delegate,
+    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,
+    system: sq.system ?? "client"
+  });
+  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.related.correlation.parentField,
+    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: condition2.related.system === "permissions" ? PERMISSIONS_EXISTS_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 = 3;
+var PERMISSIONS_EXISTS_LIMIT = 1;
+function assertOrderingIncludesPK(ordering, pk) {
+  const orderingFields = ordering.map(([field]) => field);
+  const missingFields = pk.filter((pkField) => !orderingFields.includes(pkField));
+  if (missingFields.length > 0) {
+    throw new Error(
+      `Ordering must include all primary key fields. Missing: ${missingFields.join(
+        ", "
+      )}. ZQL automatically appends primary key fields to the ordering if they are missing 
+      so a common cause of this error is a casing mismatch between Postgres and ZQL.
+      E.g., "userid" vs "userID".
+      You may want to add double-quotes around your Postgres column names to prevent Postgres from lower-casing them:
+      https://www.postgresql.org/docs/current/sql-syntax-lexical.htm`
+    );
+  }
+}
+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 {
+  #input;
+  #listeners = /* @__PURE__ */ new Set();
+  #schema;
+  #format;
+  // Synthetic "root" entry that has a single "" relationship, so that we can
+  // treat all changes, including the root change, generically.
+  #root;
+  onDestroy;
+  #dirty = false;
+  #complete = false;
+  constructor(input, format = { singular: false, relationships: {} }, queryComplete = true) {
+    this.#input = input;
+    this.#schema = input.getSchema();
+    this.#format = format;
+    this.#root = { "": format.singular ? void 0 : [] };
+    input.setOutput(this);
+    if (queryComplete === true) {
+      this.#complete = true;
+    } else {
+      void queryComplete.then(() => {
+        this.#complete = true;
+        this.#fireListeners();
+      });
+    }
+    this.#hydrate();
+  }
+  get data() {
+    return this.#root[""];
+  }
+  addListener(listener) {
+    assert(!this.#listeners.has(listener), "Listener already registered");
+    this.#listeners.add(listener);
+    this.#fireListener(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  #fireListeners() {
+    for (const listener of this.#listeners) {
+      this.#fireListener(listener);
+    }
+  }
+  #fireListener(listener) {
+    listener(
+      this.data,
+      this.#complete ? "complete" : "unknown"
+    );
+  }
+  destroy() {
+    this.onDestroy?.();
+  }
+  #hydrate() {
+    this.#dirty = true;
+    for (const node of this.#input.fetch({})) {
+      applyChange(
+        this.#root,
+        { type: "add", node },
+        this.#schema,
+        "",
+        this.#format
+      );
+    }
+    this.flush();
+  }
+  push(change) {
+    this.#dirty = true;
+    applyChange(this.#root, change, this.#schema, "", this.#format);
+  }
+  flush() {
+    if (!this.#dirty) {
+      return;
+    }
+    this.#dirty = false;
+    this.#fireListeners();
+  }
+};
+
+// ../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);
+  }
+  cmpLit(left, op, right) {
+    return {
+      type: "simple",
+      left: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
+      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
+      op
+    };
+  }
+  and = and;
+  or = or;
+  not = not2;
+  exists(relationship, cb) {
+    return this.#exists(relationship, cb);
+  }
+};
+function and(...conditions) {
+  const expressions = filterTrue(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysFalse)) {
+    return FALSE;
+  }
+  return { type: "and", conditions: expressions };
+}
+function or(...conditions) {
+  const expressions = filterFalse(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
+  }
+  if (expressions.some(isAlwaysTrue)) {
+    return TRUE;
+  }
+  return { type: "or", conditions: expressions };
+}
+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)
+      };
+    case "simple":
+      return {
+        type: "simple",
+        op: negateOperator(expression.op),
+        left: expression.left,
+        right: expression.right
+      };
+  }
+}
+function cmp(field, opOrValue, value) {
+  let op;
+  if (value === void 0) {
+    value = opOrValue;
+    op = "=";
+  } else {
+    op = opOrValue;
+  }
+  return {
+    type: "simple",
+    left: { type: "column", name: field },
+    right: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
+    op
+  };
+}
+function isParameterReference(value) {
+  return value !== null && typeof value === "object" && value[toStaticParam];
+}
+var TRUE = {
+  type: "and",
+  conditions: []
+};
+var FALSE = {
+  type: "or",
+  conditions: []
+};
+function isAlwaysTrue(condition) {
+  return condition.type === "and" && condition.conditions.length === 0;
+}
+function isAlwaysFalse(condition) {
+  return condition.type === "or" && condition.conditions.length === 0;
+}
+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 filterUndefined(array5) {
+  return array5.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 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
+var astForTestingSymbol = Symbol();
+function newQuery(delegate, schema, table) {
+  return new QueryImpl(delegate, schema, table);
+}
+function newQueryWithDetails(delegate, schema, tableName, ast, ttl, format) {
+  return new QueryImpl(delegate, schema, tableName, ast, ttl, format);
+}
+function staticParam(anchorClass, field) {
+  return {
+    type: "static",
+    anchor: anchorClass,
+    // for backwards compatibility
+    field: field.length === 1 ? field[0] : field
+  };
+}
+var SUBQ_PREFIX = "zsubq_";
+var AbstractQuery = class {
+  #schema;
+  #tableName;
+  #ast;
+  #ttl;
+  #format;
+  #hash = "";
+  constructor(schema, tableName, ast = { table: tableName }, ttl, format) {
+    this.#schema = schema;
+    this.#tableName = tableName;
+    this.#ast = ast;
+    this.#ttl = ttl;
+    this.#format = format ?? { singular: false, relationships: {} };
+  }
+  get format() {
+    return this.#format;
+  }
+  // Not part of Query or QueryInternal interface
+  get [astForTestingSymbol]() {
+    return this.#ast;
+  }
+  hash() {
+    if (!this.#hash) {
+      const ast = this._completeAst();
+      const hash2 = hashOfAST(ast);
+      this.#hash = hash2;
+    }
+    return this.#hash;
+  }
+  one() {
+    return this._newQuery(
+      this.#schema,
+      this.#tableName,
+      {
+        ...this.#ast,
+        limit: 1
+      },
+      this.#ttl,
+      {
+        ...this.#format,
+        singular: true
+      }
+    );
+  }
+  whereExists(relationship, cb) {
+    return this.where(({ exists }) => exists(relationship, cb));
+  }
+  related(relationship, cb) {
+    if (relationship.startsWith(SUBQ_PREFIX)) {
+      throw new Error(
+        `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
+      );
+    }
+    cb = cb ?? ((q) => q);
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema, destField, sourceField, cardinality } = related[0];
+      const sq = cb(
+        this._newQuery(
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: relationship
+          },
+          this.#ttl,
+          {
+            relationships: {},
+            singular: cardinality === "one"
+          }
+        )
+      );
+      assert(
+        isCompoundKey(sourceField),
+        "The source of a relationship must specify at last 1 field"
+      );
+      assert(
+        isCompoundKey(destField),
+        "The destination of a relationship must specify at last 1 field"
+      );
+      assert(
+        sourceField.length === destField.length,
+        "The source and destination of a relationship must have the same number of fields"
+      );
+      return this._newQuery(
+        this.#schema,
+        this.#tableName,
+        {
+          ...this.#ast,
+          related: [
+            ...this.#ast.related ?? [],
+            {
+              system: this._system,
+              correlation: {
+                parentField: sourceField,
+                childField: destField
+              },
+              subquery: addPrimaryKeysToAst(
+                this.#schema.tables[destSchema],
+                sq.#ast
+              )
+            }
+          ]
+        },
+        this.#ttl,
+        {
+          ...this.#format,
+          relationships: {
+            ...this.#format.relationships,
+            [relationship]: sq.#format
+          }
+        }
+      );
+    }
+    if (isTwoHop(related)) {
+      assert(related.length === 2, "Invalid relationship");
+      const [firstRelation, secondRelation] = related;
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const sq = cb(
+        this._newQuery(
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: relationship
+          },
+          this.#ttl,
+          {
+            relationships: {},
+            singular: secondRelation.cardinality === "one"
+          }
+        )
+      );
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      return this._newQuery(
+        this.#schema,
+        this.#tableName,
+        {
+          ...this.#ast,
+          related: [
+            ...this.#ast.related ?? [],
+            {
+              system: this._system,
+              correlation: {
+                parentField: firstRelation.sourceField,
+                childField: firstRelation.destField
+              },
+              hidden: true,
+              subquery: {
+                table: junctionSchema,
+                alias: relationship,
+                orderBy: addPrimaryKeys(
+                  this.#schema.tables[junctionSchema],
+                  void 0
+                ),
+                related: [
+                  {
+                    system: this._system,
+                    correlation: {
+                      parentField: secondRelation.sourceField,
+                      childField: secondRelation.destField
+                    },
+                    subquery: addPrimaryKeysToAst(
+                      this.#schema.tables[destSchema],
+                      sq.#ast
+                    )
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        this.#ttl,
+        {
+          ...this.#format,
+          relationships: {
+            ...this.#format.relationships,
+            [relationship]: sq.#format
+          }
+        }
+      );
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  }
+  where(fieldOrExpressionFactory, opOrValue, value) {
+    let cond;
+    if (typeof fieldOrExpressionFactory === "function") {
+      cond = fieldOrExpressionFactory(
+        new ExpressionBuilder(this._exists)
+      );
+    } else {
+      assert(opOrValue !== void 0, "Invalid condition");
+      cond = cmp(fieldOrExpressionFactory, opOrValue, value);
+    }
+    const existingWhere = this.#ast.where;
+    if (existingWhere) {
+      cond = and(existingWhere, cond);
+    }
+    return this._newQuery(
+      this.#schema,
+      this.#tableName,
+      {
+        ...this.#ast,
+        where: dnf(cond)
+      },
+      this.#ttl,
+      this.#format
+    );
+  }
+  start(row, opts) {
+    return this._newQuery(
+      this.#schema,
+      this.#tableName,
+      {
+        ...this.#ast,
+        start: {
+          row,
+          exclusive: !opts?.inclusive
+        }
+      },
+      this.#ttl,
+      this.#format
+    );
+  }
+  limit(limit) {
+    if (limit < 0) {
+      throw new Error("Limit must be non-negative");
+    }
+    if ((limit | 0) !== limit) {
+      throw new Error("Limit must be an integer");
+    }
+    return this._newQuery(
+      this.#schema,
+      this.#tableName,
+      {
+        ...this.#ast,
+        limit
+      },
+      this.#ttl,
+      this.#format
+    );
+  }
+  orderBy(field, direction) {
+    return this._newQuery(
+      this.#schema,
+      this.#tableName,
+      {
+        ...this.#ast,
+        orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
+      },
+      this.#ttl,
+      this.#format
+    );
+  }
+  _exists = (relationship, cb = (q) => q) => {
+    const related = this.#schema.relationships[this.#tableName][relationship];
+    assert(related, "Invalid relationship");
+    if (isOneHop(related)) {
+      const { destSchema, sourceField, destField } = related[0];
+      assert(isCompoundKey(sourceField), "Invalid relationship");
+      assert(isCompoundKey(destField), "Invalid relationship");
+      const sq = cb(
+        this._newQuery(
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`
+          },
+          this.#ttl,
+          void 0
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this._system,
+          correlation: {
+            parentField: sourceField,
+            childField: destField
+          },
+          subquery: addPrimaryKeysToAst(
+            this.#schema.tables[destSchema],
+            sq.#ast
+          )
+        },
+        op: "EXISTS"
+      };
+    }
+    if (isTwoHop(related)) {
+      assert(related.length === 2, "Invalid relationship");
+      const [firstRelation, secondRelation] = related;
+      assert(isCompoundKey(firstRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(firstRelation.destField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.sourceField), "Invalid relationship");
+      assert(isCompoundKey(secondRelation.destField), "Invalid relationship");
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
+      const queryToDest = cb(
+        this._newQuery(
+          this.#schema,
+          destSchema,
+          {
+            table: destSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`
+          },
+          this.#ttl,
+          void 0
+        )
+      );
+      return {
+        type: "correlatedSubquery",
+        related: {
+          system: this._system,
+          correlation: {
+            parentField: firstRelation.sourceField,
+            childField: firstRelation.destField
+          },
+          subquery: {
+            table: junctionSchema,
+            alias: `${SUBQ_PREFIX}${relationship}`,
+            orderBy: addPrimaryKeys(
+              this.#schema.tables[junctionSchema],
+              void 0
+            ),
+            where: {
+              type: "correlatedSubquery",
+              related: {
+                system: this._system,
+                correlation: {
+                  parentField: secondRelation.sourceField,
+                  childField: secondRelation.destField
+                },
+                subquery: addPrimaryKeysToAst(
+                  this.#schema.tables[destSchema],
+                  queryToDest.#ast
+                )
+              },
+              op: "EXISTS"
+            }
+          }
+        },
+        op: "EXISTS"
+      };
+    }
+    throw new Error(`Invalid relationship ${relationship}`);
+  };
+  #completedAST;
+  _completeAst() {
+    if (!this.#completedAST) {
+      const finalOrderBy = addPrimaryKeys(
+        this.#schema.tables[this.#tableName],
+        this.#ast.orderBy
+      );
+      if (this.#ast.start) {
+        const { row } = this.#ast.start;
+        const narrowedRow = {};
+        for (const [field] of finalOrderBy) {
+          narrowedRow[field] = row[field];
+        }
+        this.#completedAST = {
+          ...this.#ast,
+          start: {
+            ...this.#ast.start,
+            row: narrowedRow
+          },
+          orderBy: finalOrderBy
+        };
+      } else {
+        this.#completedAST = {
+          ...this.#ast,
+          orderBy: addPrimaryKeys(
+            this.#schema.tables[this.#tableName],
+            this.#ast.orderBy
+          )
+        };
+      }
+    }
+    return this.#completedAST;
+  }
+};
+var completedAstSymbol = Symbol();
+var QueryImpl = class extends AbstractQuery {
+  #delegate;
+  constructor(delegate, schema, tableName, ast, ttl, format) {
+    super(schema, tableName, ast, ttl, format);
+    this.#delegate = delegate;
+  }
+  _system = "client";
+  get [completedAstSymbol]() {
+    return this._completeAst();
+  }
+  _newQuery(schema, tableName, ast, ttl, format) {
+    return newQueryWithDetails(
+      this.#delegate,
+      schema,
+      tableName,
+      ast,
+      ttl,
+      format
+    );
+  }
+  materialize(factory) {
+    const ast = this._completeAst();
+    const queryCompleteResolver = resolver();
+    let queryGot = false;
+    const ttl = void 0;
+    const removeServerQuery = this.#delegate.addServerQuery(ast, ttl, (got) => {
+      if (got) {
+        queryGot = true;
+        queryCompleteResolver.resolve(true);
+      }
+    });
+    const input = buildPipeline(ast, this.#delegate);
+    let removeCommitObserver;
+    const onDestroy = () => {
+      input.destroy();
+      removeCommitObserver?.();
+      removeServerQuery();
+    };
+    const view = this.#delegate.batchViewUpdates(
+      () => (factory ?? arrayViewFactory)(
+        this,
+        input,
+        this.format,
+        onDestroy,
+        (cb) => {
+          removeCommitObserver = this.#delegate.onTransactionCommit(cb);
+        },
+        queryGot || queryCompleteResolver.promise
+      )
+    );
+    return view;
+  }
+  run() {
+    const v2 = this.materialize();
+    const ret = v2.data;
+    v2.destroy();
+    return Promise.resolve(ret);
+  }
+  preload() {
+    const { resolve, promise: complete } = resolver();
+    const ast = this._completeAst();
+    const ttl = void 0;
+    const unsub = this.#delegate.addServerQuery(ast, ttl, (got) => {
+      if (got) {
+        resolve();
+      }
+    });
+    return {
+      cleanup: unsub,
+      complete
+    };
+  }
+};
+function addPrimaryKeys(schema, orderBy) {
+  orderBy = orderBy ?? [];
+  const { primaryKey } = schema;
+  const primaryKeysToAdd = new Set(primaryKey);
+  for (const [field] of orderBy) {
+    primaryKeysToAdd.delete(field);
+  }
+  if (primaryKeysToAdd.size === 0) {
+    return orderBy;
+  }
+  return [
+    ...orderBy,
+    ...[...primaryKeysToAdd].map((key) => [key, "asc"])
+  ];
+}
+function addPrimaryKeysToAst(schema, ast) {
+  return {
+    ...ast,
+    orderBy: addPrimaryKeys(schema, ast.orderBy)
+  };
+}
+function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit, queryComplete) {
+  const v2 = new ArrayView(input, format, queryComplete);
+  v2.onDestroy = onDestroy;
+  onTransactionCommit(() => {
+    v2.flush();
+  });
+  return v2;
+}
+function isCompoundKey(field) {
+  return Array.isArray(field) && field.length >= 1;
+}
+
+// ../zero-protocol/src/mutation-type-enum.ts
+var CRUD = "crud";
+var Custom = "custom";
+
+// ../zero-protocol/src/primary-key.ts
+var primaryKeySchema = readonly(
+  valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
+);
+var primaryKeyValueSchema = valita_exports.union(
+  valita_exports.string(),
+  valita_exports.number(),
+  valita_exports.boolean()
+);
+var primaryKeyValueRecordSchema = readonlyRecord(
+  primaryKeyValueSchema
+);
+
+// ../zero-protocol/src/push.ts
+var CRUD_MUTATION_NAME = "_zero_crud";
+var insertOpSchema = valita_exports.object({
+  op: valita_exports.literal("insert"),
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  value: rowSchema
+});
+var upsertOpSchema = valita_exports.object({
+  op: valita_exports.literal("upsert"),
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  value: rowSchema
+});
+var updateOpSchema = valita_exports.object({
+  op: valita_exports.literal("update"),
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  // Partial value with at least the primary key fields
+  value: rowSchema
+});
+var deleteOpSchema = valita_exports.object({
+  op: valita_exports.literal("delete"),
+  tableName: valita_exports.string(),
+  primaryKey: primaryKeySchema,
+  // Partial value representing the primary key
+  value: primaryKeyValueRecordSchema
+});
+var crudOpSchema = valita_exports.union(
+  insertOpSchema,
+  upsertOpSchema,
+  updateOpSchema,
+  deleteOpSchema
+);
+var crudArgSchema = valita_exports.object({
+  ops: valita_exports.array(crudOpSchema)
+});
+var crudArgsSchema = valita_exports.tuple([crudArgSchema]);
+var crudMutationSchema = valita_exports.object({
+  type: valita_exports.literal(CRUD),
+  id: valita_exports.number(),
+  clientID: valita_exports.string(),
+  name: valita_exports.literal(CRUD_MUTATION_NAME),
+  args: crudArgsSchema,
+  timestamp: valita_exports.number()
+});
+var customMutationSchema = valita_exports.object({
+  type: valita_exports.literal(Custom),
+  id: valita_exports.number(),
+  clientID: valita_exports.string(),
+  name: valita_exports.string(),
+  args: valita_exports.array(jsonSchema),
+  timestamp: valita_exports.number()
+});
+var mutationSchema = valita_exports.union(crudMutationSchema, customMutationSchema);
+var pushBodySchema = valita_exports.object({
+  clientGroupID: valita_exports.string(),
+  mutations: valita_exports.array(mutationSchema),
+  pushVersion: valita_exports.number(),
+  schemaVersion: valita_exports.number(),
+  timestamp: valita_exports.number(),
+  requestID: valita_exports.string()
+});
+var pushMessageSchema = valita_exports.tuple([valita_exports.literal("push"), pushBodySchema]);
+var mutationIDSchema = valita_exports.object({
+  id: valita_exports.number(),
+  clientID: valita_exports.string()
+});
+var appErrorSchema = valita_exports.object({
+  error: valita_exports.literal("app"),
+  details: valita_exports.string()
+});
+var zeroErrorSchema = valita_exports.object({
+  error: valita_exports.literal("ooo-mutation")
+});
+var mutationOkSchema = valita_exports.object({});
+var mutationErrorSchema = valita_exports.union(appErrorSchema, zeroErrorSchema);
+var mutationResultSchema = valita_exports.union(mutationOkSchema, mutationErrorSchema);
+var mutationResponseSchema = valita_exports.object({
+  id: mutationIDSchema,
+  result: mutationResultSchema
+});
+var pushOkSchema = valita_exports.object({
+  mutations: valita_exports.array(mutationResponseSchema)
+});
+var unsupportedPushVersionSchema = valita_exports.object({
+  error: valita_exports.literal("unsupported-push-version")
+});
+var unsupportedSchemaVersionSchema = valita_exports.object({
+  error: valita_exports.literal("unsupported-schema-version")
+});
+var pushErrorSchema = valita_exports.union(
+  unsupportedPushVersionSchema,
+  unsupportedSchemaVersionSchema
+);
+var pushResponseSchema = valita_exports.union(pushOkSchema, pushErrorSchema);
+function mapCRUD(arg, map) {
+  return {
+    ops: arg.ops.map(
+      ({ op, tableName, primaryKey, value }) => ({
+        op,
+        tableName: map.tableName(tableName),
+        primaryKey: map.columns(tableName, primaryKey),
+        value: map.row(tableName, value)
+        // The cast is necessary because ts objects to the `value` field
+        // for "delete" ops being different.
+      })
+    )
+  };
+}
+
+// ../zql/src/mutate/custom.ts
+function customMutatorKey(namespace, name) {
+  assert(!namespace.includes("|"), "mutator namespaces must not include a |");
+  assert(!name.includes("|"), "mutator names must not include a |");
+  return `${namespace}|${name}`;
+}
+function splitMutatorKey(key) {
+  return key.split("|");
+}
+
+export {
+  isProd,
+  deepEqual,
+  assertJSONValue,
+  assertJSONObject,
+  parse,
+  assert2 as assert,
+  test,
+  readonlyObject,
+  readonlyArray,
+  readonlyRecord,
+  valita_exports,
+  joinIterables,
+  first2 as first,
+  wrapIterable,
+  jsonSchema,
+  jsonObjectSchema,
+  rowSchema,
+  toStaticParam,
+  astSchema,
+  normalizeAST,
+  mapAST,
+  mapCondition,
+  h128,
+  hashOfAST,
+  filterPush,
+  createPredicate,
+  transformFilters,
+  assertOrderingIncludesPK,
+  ExpressionBuilder,
+  newQuery,
+  staticParam,
+  AbstractQuery,
+  primaryKeyValueSchema,
+  primaryKeyValueRecordSchema,
+  CRUD,
+  Custom,
+  CRUD_MUTATION_NAME,
+  pushBodySchema,
+  mapCRUD,
+  customMutatorKey,
+  splitMutatorKey
+};
+//# sourceMappingURL=chunk-P3NUVEQJ.js.map