zero-swift 0.0.0 → 0.1.0

package/dist/drift-S756Q2ZA.js

@@ -0,0 +1,2230 @@
+// src/drift.ts
+import { pathToFileURL } from "node:url";
+import {
+  createBuilder,
+  defineMutator,
+  defineMutators,
+  isMutator,
+  isQuery,
+  mustGetMutator,
+  mustGetQuery,
+  Zero
+} from "@rocicorp/zero";
+
+// ../shared/src/map.ts
+function hasNative(name) {
+  return typeof Map.prototype[name] === "function" && typeof WeakMap.prototype[name] === "function";
+}
+function getOrInsertPolyfill(map, key, defaultValue) {
+  const existing = map.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  map.set(key, defaultValue);
+  return defaultValue;
+}
+function getOrInsertComputedPolyfill(map, key, compute) {
+  const existing = map.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const value = compute(key);
+  map.set(key, value);
+  return value;
+}
+function getOrInsertNative(map, key, defaultValue) {
+  return map.getOrInsert(key, defaultValue);
+}
+function getOrInsertComputedNative(map, key, compute) {
+  return map.getOrInsertComputed(key, compute);
+}
+var getOrInsert = hasNative("getOrInsert") ? getOrInsertNative : getOrInsertPolyfill;
+var getOrInsertComputed = hasNative("getOrInsertComputed") ? getOrInsertComputedNative : getOrInsertComputedPolyfill;
+
+// ../../node_modules/.pnpm/compare-utf8@0.2.3/node_modules/compare-utf8/src/index.js
+var surrogateRe = /[\uD800-\uDFFF]/;
+var BISECT_MIN_LENGTH = 64;
+function compareSlow(a, b) {
+  const aLength = a.length;
+  const bLength = b.length;
+  const length = aLength > bLength ? bLength : aLength;
+  let i = 0;
+  if (length >= BISECT_MIN_LENGTH) {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (a.slice(0, mid) === b.slice(0, mid)) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    i = lo;
+  }
+  for (; i < length; i++) {
+    const ac = a.charCodeAt(i);
+    const bc = b.charCodeAt(i);
+    if (ac !== bc) {
+      if (i > 0) {
+        const prev = a.charCodeAt(i - 1);
+        if (prev >= 55296 && prev <= 56319) {
+          const d = (
+            /** @type {number} */
+            a.codePointAt(i - 1) - /** @type {number} */
+            b.codePointAt(i - 1)
+          );
+          if (d !== 0) return d;
+        }
+      }
+      if ((ac < 55296 || ac > 57343) && (bc < 55296 || bc > 57343)) {
+        return ac - bc;
+      }
+      return (
+        /** @type {number} */
+        a.codePointAt(i) - /** @type {number} */
+        b.codePointAt(i)
+      );
+    }
+  }
+  return aLength - bLength;
+}
+function compareUTF8(a, b) {
+  if (a === b) return 0;
+  if (a < b) {
+    return surrogateRe.test(a) ? compareSlow(a, b) : -1;
+  }
+  return surrogateRe.test(b) ? compareSlow(a, b) : 1;
+}
+
+// ../shared/src/asserts.ts
+function assert(b, msg) {
+  if (!b) {
+    throw new Error(typeof msg === "string" ? msg : msg());
+  }
+}
+function unreachable(_) {
+  throw new Error("Unreachable");
+}
+
+// ../shared/src/deep-merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// ../shared/src/must.ts
+function must(v, msg) {
+  if (v == null) {
+    throw new Error(msg ?? `Unexpected ${v} value`);
+  }
+  return v;
+}
+
+// ../../node_modules/.pnpm/@badrap+valita@0.5.5/node_modules/@badrap/valita/dist/index.js
+function customError(error) {
+  return {
+    ok: false,
+    code: "custom_error",
+    path: typeof error === "object" ? error.path : void 0,
+    message: typeof error === "string" ? error : error?.message ?? "validation failed",
+    error
+  };
+}
+function expectedType(expected) {
+  return {
+    ok: false,
+    code: "invalid_type",
+    message: `expected ${separatedList(expected, "or")}`,
+    expected
+  };
+}
+function expectedLiteral(literals) {
+  return {
+    ok: false,
+    code: "invalid_literal",
+    message: `expected ${separatedList(literals.map(formatLiteral), "or")}`,
+    expected: literals
+  };
+}
+var UnrecognizedKeysIssue = class {
+  ok = false;
+  code = "unrecognized_keys";
+  keys;
+  constructor(keys) {
+    this.keys = keys;
+  }
+  get message() {
+    const keys = this.keys;
+    if (keys.length === 1) {
+      return `unrecognized key ${formatLiteral(keys[0])}`;
+    } else if (keys.length < 8) {
+      return `unrecognized keys ${separatedList(keys.map(formatLiteral), "and")}`;
+    } else {
+      return `unrecognized keys ${keys.map(formatLiteral).join(",")} and ${keys.length - 6} others`;
+    }
+  }
+};
+function unrecognizedKeys(keys) {
+  return new UnrecognizedKeysIssue(keys);
+}
+function invalidUnion(tree) {
+  return {
+    ok: false,
+    code: "invalid_union",
+    message: "validation failed",
+    tree
+  };
+}
+var ISSUE_EXPECTED_NOTHING = expectedType([]);
+var ISSUE_EXPECTED_STRING = expectedType(["string"]);
+var ISSUE_EXPECTED_NUMBER = expectedType(["number"]);
+var ISSUE_EXPECTED_BIGINT = expectedType(["bigint"]);
+var ISSUE_EXPECTED_BOOLEAN = expectedType(["boolean"]);
+var ISSUE_EXPECTED_UNDEFINED = expectedType(["undefined"]);
+var ISSUE_EXPECTED_NULL = expectedType(["null"]);
+var ISSUE_EXPECTED_OBJECT = expectedType(["object"]);
+var ISSUE_EXPECTED_ARRAY = expectedType(["array"]);
+var ISSUE_MISSING_VALUE = {
+  ok: false,
+  code: "missing_value",
+  message: "missing value"
+};
+function joinIssues(left, right) {
+  return left ? { ok: false, code: "join", left, right } : right;
+}
+function prependPath(key, tree) {
+  return { ok: false, code: "prepend", key, tree };
+}
+function cloneIssueWithPath(tree, path2) {
+  const code = tree.code;
+  switch (code) {
+    case "invalid_type":
+      return {
+        path: path2,
+        message: tree.message,
+        code,
+        expected: tree.expected
+      };
+    case "invalid_literal":
+      return {
+        path: path2,
+        message: tree.message,
+        code,
+        expected: tree.expected
+      };
+    case "missing_value":
+      return {
+        path: path2,
+        message: tree.message,
+        code
+      };
+    case "invalid_length": {
+      return {
+        path: path2,
+        message: tree.message,
+        code,
+        minLength: tree.minLength,
+        maxLength: tree.maxLength
+      };
+    }
+    case "unrecognized_keys": {
+      return {
+        path: path2,
+        message: tree.message,
+        code,
+        keys: tree.keys
+      };
+    }
+    case "invalid_union":
+      return {
+        code,
+        path: path2,
+        message: tree.message,
+        issues: collectIssues(tree.tree)
+      };
+    case "custom_error":
+      if (tree.path !== void 0) {
+        path2.push(...tree.path);
+      }
+      return {
+        path: path2,
+        message: tree.message,
+        code
+      };
+  }
+}
+function collectIssues(tree, path2 = [], issues = []) {
+  for (; ; ) {
+    if (tree.code === "join") {
+      collectIssues(tree.left, path2.slice(), issues);
+      tree = tree.right;
+    } else if (tree.code === "prepend") {
+      path2.push(tree.key);
+      tree = tree.tree;
+    } else {
+      issues.push(cloneIssueWithPath(tree, path2));
+      return issues;
+    }
+  }
+}
+function separatedList(list, sep) {
+  if (list.length === 0) {
+    return "nothing";
+  } else if (list.length === 1) {
+    return list[0];
+  } else {
+    return `${list.slice(0, -1).join(", ")} ${sep} ${list[list.length - 1]}`;
+  }
+}
+function formatLiteral(value) {
+  return typeof value === "bigint" ? `${value}n` : JSON.stringify(value);
+}
+function countIssues(tree) {
+  let count = 0;
+  for (; ; ) {
+    if (tree.code === "join") {
+      count += countIssues(tree.left);
+      tree = tree.right;
+    } else if (tree.code === "prepend") {
+      tree = tree.tree;
+    } else {
+      return count + 1;
+    }
+  }
+}
+function formatIssueTree(tree) {
+  let path2 = "";
+  let count = 0;
+  for (; ; ) {
+    if (tree.code === "join") {
+      count += countIssues(tree.right);
+      tree = tree.left;
+    } else if (tree.code === "prepend") {
+      path2 += `.${tree.key}`;
+      tree = tree.tree;
+    } else {
+      break;
+    }
+  }
+  if (tree.code === "custom_error" && tree.path) {
+    path2 += "." + tree.path.join(".");
+  }
+  let msg = `${tree.code} at ${path2 || "."} (${tree.message})`;
+  if (count === 1) {
+    msg += ` (+ 1 other issue)`;
+  } else if (count > 1) {
+    msg += ` (+ ${count} other issues)`;
+  }
+  return msg;
+}
+var ValitaError = class extends Error {
+  #issueTree;
+  #issues;
+  #message;
+  constructor(issueTree) {
+    super();
+    this.#issueTree = issueTree;
+  }
+  get issues() {
+    return this.#issues ??= collectIssues(this.#issueTree);
+  }
+  get message() {
+    return this.#message ??= formatIssueTree(this.#issueTree);
+  }
+};
+ValitaError.prototype.name = "ValitaError";
+var OkImpl = class {
+  ok = true;
+  value;
+  static {
+    this.prototype.issues = void 0;
+  }
+  constructor(value) {
+    this.value = value;
+  }
+};
+var ErrImpl = class {
+  ok = false;
+  /** @internal */
+  _issueTree;
+  #message;
+  #issues;
+  constructor(issueTree) {
+    this._issueTree = issueTree;
+  }
+  get issues() {
+    return this.#issues ??= collectIssues(this._issueTree);
+  }
+  get message() {
+    return this.#message ??= formatIssueTree(this._issueTree);
+  }
+  throw() {
+    throw new ValitaError(this._issueTree);
+  }
+};
+function ok(value) {
+  return new OkImpl(value);
+}
+function err(error) {
+  return new ErrImpl(customError(error));
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var FLAG_FORBID_EXTRA_KEYS = 1 << 0;
+var FLAG_STRIP_EXTRA_KEYS = 1 << 1;
+var FLAG_MISSING_VALUE = 1 << 2;
+var TAG_UNKNOWN = 0;
+var TAG_NEVER = 1;
+var TAG_STRING = 2;
+var TAG_NUMBER = 3;
+var TAG_BIGINT = 4;
+var TAG_BOOLEAN = 5;
+var TAG_NULL = 6;
+var TAG_UNDEFINED = 7;
+var TAG_LITERAL = 8;
+var TAG_OPTIONAL = 9;
+var TAG_OBJECT = 10;
+var TAG_ARRAY = 11;
+var TAG_UNION = 12;
+var TAG_SIMPLE_UNION = 13;
+var TAG_TRANSFORM = 14;
+var TAG_OTHER = 15;
+var taggedMatcher = (tag, match) => {
+  return { tag, match };
+};
+function callMatcher(matcher, value, flags) {
+  switch (matcher.tag) {
+    case TAG_UNKNOWN:
+      return void 0;
+    case TAG_NEVER:
+      return ISSUE_EXPECTED_NOTHING;
+    case TAG_STRING:
+      return typeof value === "string" ? void 0 : ISSUE_EXPECTED_STRING;
+    case TAG_NUMBER:
+      return typeof value === "number" ? void 0 : ISSUE_EXPECTED_NUMBER;
+    case TAG_BIGINT:
+      return typeof value === "bigint" ? void 0 : ISSUE_EXPECTED_BIGINT;
+    case TAG_BOOLEAN:
+      return typeof value === "boolean" ? void 0 : ISSUE_EXPECTED_BOOLEAN;
+    case TAG_NULL:
+      return value === null ? void 0 : ISSUE_EXPECTED_NULL;
+    case TAG_UNDEFINED:
+      return value === void 0 ? void 0 : ISSUE_EXPECTED_UNDEFINED;
+    case TAG_LITERAL:
+      return matcher.match(value, flags);
+    case TAG_OPTIONAL:
+      return matcher.match(value, flags);
+    case TAG_OBJECT:
+      return matcher.match(value, flags);
+    case TAG_ARRAY:
+      return matcher.match(value, flags);
+    case TAG_UNION:
+      return matcher.match(value, flags);
+    case TAG_SIMPLE_UNION:
+      return matcher.match(value, flags);
+    case TAG_TRANSFORM:
+      return matcher.match(value, flags);
+    default:
+      return matcher.match(value, flags);
+  }
+}
+var MATCHER_SYMBOL = /* @__PURE__ */ Symbol.for("@valita/internal");
+var AbstractType = class {
+  #standard;
+  get "~standard"() {
+    return this.#standard ??= {
+      version: 1,
+      vendor: "@badrap/valita",
+      validate: (value, options) => {
+        return this.try(value, options?.libraryOptions);
+      }
+    };
+  }
+  /**
+   * Parse a value without throwing.
+   */
+  try(v, options) {
+    const r = callMatcher(this[MATCHER_SYMBOL], v, options === void 0 ? FLAG_FORBID_EXTRA_KEYS : options.mode === "strip" ? FLAG_STRIP_EXTRA_KEYS : options.mode === "passthrough" ? 0 : FLAG_FORBID_EXTRA_KEYS);
+    return r === void 0 || r.ok ? new OkImpl(r === void 0 ? v : r.value) : new ErrImpl(r);
+  }
+  /**
+   * Parse a value. Throw a ValitaError on failure.
+   */
+  parse(v, options) {
+    const r = callMatcher(this[MATCHER_SYMBOL], v, options === void 0 ? FLAG_FORBID_EXTRA_KEYS : options.mode === "strip" ? FLAG_STRIP_EXTRA_KEYS : options.mode === "passthrough" ? 0 : FLAG_FORBID_EXTRA_KEYS);
+    if (r === void 0 || r.ok) {
+      return r === void 0 ? v : r.value;
+    }
+    throw new ValitaError(r);
+  }
+  /**
+   * Derive a new validator that uses the provided predicate function to
+   * perform custom validation for the source validator's output values.
+   *
+   * The predicate function should return `true` when the source
+   * type's output value is valid, `false` otherwise. The checked value
+   * itself won't get modified or replaced, and is returned as-is on
+   * validation success.
+   *
+   * @example A validator that accepts only numeric strings.
+   * ```ts
+   * const numericString = v.string().assert((s) => /^\d+$/.test(s))
+   * numericString.parse("1");
+   * // "1"
+   * numericString.parse("foo");
+   * // ValitaError: custom_error at . (validation failed)
+   * ```
+   *
+   * You can also _refine_ the output type by passing in a
+   * [type predicate](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates).
+   * Note that the type predicate must have a compatible input type.
+   *
+   * @example A validator with its output type refined to `Date`.
+   * ```ts
+   * const dateType = v.unknown().assert((v): v is Date => v instanceof Date);
+   * ```
+   *
+   * You can also pass in a custom failure messages.
+   *
+   * @example A validator that rejects non-integers with a custom error.
+   * ```ts
+   * const integer = v.number().assert((n) => Number.isInteger(n), "not an integer");
+   * integer.parse(1);
+   * // 1
+   * integer.parse(1.5);
+   * // ValitaError: custom_error at . (not an integer)
+   * ```
+   *
+   * @param func - The assertion predicate function.
+   * @param [error] - A custom error for situations when the assertion
+   *                  predicate returns `false`.
+   */
+  assert(func, error) {
+    const err2 = customError(error);
+    return new TransformType(this, (v, flags) => func(v, flagsToOptions(flags)) ? void 0 : err2);
+  }
+  map(func) {
+    return new TransformType(this, (v, flags) => ({
+      ok: true,
+      value: func(v, flagsToOptions(flags))
+    }));
+  }
+  chain(input) {
+    if (typeof input === "function") {
+      return new TransformType(this, (v, flags) => {
+        const r = input(v, flagsToOptions(flags));
+        return r.ok ? r : r._issueTree;
+      });
+    }
+    return new TransformType(this, (v, flags) => callMatcher(input[MATCHER_SYMBOL], v, flags));
+  }
+  /**
+   * Apply a function to this type and return its result.
+   *
+   * The function is called immediately with this type as its argument.
+   *
+   * Useful for applying reusable type modifiers.
+   *
+   * @example
+   * ```ts
+   * function nullish<T extends Type>() {
+   *   return t.nullable().optional();
+   * }
+   *
+   * const strings = v.string().as(nullish);
+   * ```
+   *
+   * @param func - The function to apply to this type.
+   * @returns The function's result.
+   */
+  as(func) {
+    return func(this);
+  }
+};
+var Type = class extends AbstractType {
+  optional(defaultFn) {
+    const optional = new Optional(this);
+    if (!defaultFn) {
+      return optional;
+    }
+    return new TransformType(optional, (v) => {
+      return v === void 0 ? { ok: true, value: defaultFn() } : void 0;
+    });
+  }
+  nullable(defaultFn) {
+    const nullable = new SimpleUnion([null_(), this]);
+    if (!defaultFn) {
+      return nullable;
+    }
+    return new TransformType(nullable, (v) => {
+      return v === null ? { ok: true, value: defaultFn() } : void 0;
+    });
+  }
+  _toTerminals(func) {
+    func(this);
+  }
+};
+var SimpleUnion = class extends Type {
+  name = "union";
+  options;
+  #matcher;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const options = this.options.map((o) => o[MATCHER_SYMBOL]);
+    return this.#matcher ??= taggedMatcher(TAG_SIMPLE_UNION, (v, flags) => {
+      let issue = ISSUE_EXPECTED_NOTHING;
+      for (const option of options) {
+        const result = callMatcher(option, v, flags);
+        if (result === void 0 || result.ok) {
+          return result;
+        }
+        issue = result;
+      }
+      return issue;
+    });
+  }
+  _toTerminals(func) {
+    for (const option of this.options) {
+      option._toTerminals(func);
+    }
+  }
+};
+var Optional = class extends AbstractType {
+  name = "optional";
+  type;
+  #matcher;
+  constructor(type) {
+    super();
+    this.type = type;
+  }
+  optional(defaultFn) {
+    if (!defaultFn) {
+      return this;
+    }
+    return new TransformType(this, (v) => {
+      return v === void 0 ? { ok: true, value: defaultFn() } : void 0;
+    });
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const matcher = this.type[MATCHER_SYMBOL];
+    return this.#matcher = taggedMatcher(TAG_OPTIONAL, (v, flags) => v === void 0 || flags & FLAG_MISSING_VALUE ? void 0 : callMatcher(matcher, v, flags));
+  }
+  _toTerminals(func) {
+    func(this);
+    func(undefined_());
+    this.type._toTerminals(func);
+  }
+};
+function setBit(bits, index) {
+  if (typeof bits !== "number") {
+    const idx = index >> 5;
+    for (let i = bits.length; i <= idx; i++) {
+      bits.push(0);
+    }
+    bits[idx] |= 1 << index % 32;
+    return bits;
+  } else if (index < 32) {
+    return bits | 1 << index;
+  } else {
+    return setBit([bits, 0], index);
+  }
+}
+function getBit(bits, index) {
+  if (typeof bits === "number") {
+    return index < 32 ? bits >>> index & 1 : 0;
+  } else {
+    return bits[index >> 5] >>> index % 32 & 1;
+  }
+}
+var ObjectType = class _ObjectType extends Type {
+  name = "object";
+  shape;
+  restType;
+  #matcher;
+  constructor(shape, restType) {
+    super();
+    this.shape = shape;
+    this.restType = restType;
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const func = createObjectMatcher(this.shape, this.restType);
+    return this.#matcher = taggedMatcher(TAG_OBJECT, (v, flags) => isObject(v) ? func(v, flags) : ISSUE_EXPECTED_OBJECT);
+  }
+  rest(restType) {
+    return new _ObjectType(this.shape, restType);
+  }
+  extend(shape) {
+    return new _ObjectType({ ...this.shape, ...shape }, this.restType);
+  }
+  pick(...keys) {
+    const shape = {};
+    for (const key of keys) {
+      set(shape, key, this.shape[key]);
+    }
+    return new _ObjectType(shape, void 0);
+  }
+  omit(...keys) {
+    const shape = { ...this.shape };
+    for (const key of keys) {
+      delete shape[key];
+    }
+    return new _ObjectType(shape, this.restType);
+  }
+  partial() {
+    const shape = {};
+    for (const key of Object.keys(this.shape)) {
+      set(shape, key, this.shape[key].optional());
+    }
+    const rest = this.restType?.optional();
+    return new _ObjectType(shape, rest);
+  }
+};
+function set(obj, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+}
+function createObjectMatcher(shape, rest) {
+  const indexedEntries = Object.keys(shape).map((key, index) => {
+    const type = shape[key];
+    let optional = false;
+    type._toTerminals((t) => {
+      optional ||= t.name === "optional";
+    });
+    return {
+      key,
+      index,
+      matcher: type[MATCHER_SYMBOL],
+      optional,
+      missing: prependPath(key, ISSUE_MISSING_VALUE)
+    };
+  });
+  const keyedEntries = /* @__PURE__ */ Object.create(null);
+  for (const entry of indexedEntries) {
+    keyedEntries[entry.key] = entry;
+  }
+  const restMatcher = rest?.[MATCHER_SYMBOL];
+  const clone = (obj, enumeratedBits, indexedBits) => {
+    const output = {};
+    if (restMatcher === void 0) {
+      for (let m = 0; m < indexedEntries.length; m++) {
+        if (getBit(enumeratedBits, m) || getBit(indexedBits, m)) {
+          const k = indexedEntries[m].key;
+          set(output, k, obj[k]);
+        }
+      }
+      return output;
+    }
+    for (const k in obj) {
+      set(output, k, obj[k]);
+    }
+    if (indexedBits) {
+      for (let m = 0; m < indexedEntries.length; m++) {
+        if (getBit(indexedBits, m)) {
+          const k = indexedEntries[m].key;
+          set(output, k, obj[k]);
+        }
+      }
+    }
+    return output;
+  };
+  const fastPath = indexedEntries.length === 0 && rest?.name === "unknown";
+  return (obj, flags) => {
+    if (fastPath) {
+      return void 0;
+    }
+    let output = void 0;
+    let issues = void 0;
+    let unrecognized = void 0;
+    let enumeratedBits = 0;
+    let indexedBits = 0;
+    let seenCount = 0;
+    if (flags & (FLAG_FORBID_EXTRA_KEYS | FLAG_STRIP_EXTRA_KEYS) || restMatcher !== void 0) {
+      for (const key in obj) {
+        const value = obj[key];
+        const entry = keyedEntries[key];
+        if (entry === void 0 && restMatcher === void 0) {
+          if (flags & FLAG_FORBID_EXTRA_KEYS) {
+            if (unrecognized === void 0) {
+              unrecognized = [key];
+            } else {
+              unrecognized.push(key);
+            }
+          } else if (flags & FLAG_STRIP_EXTRA_KEYS && issues === void 0 && output === void 0) {
+            output = clone(obj, enumeratedBits, indexedBits);
+          }
+          continue;
+        }
+        const r = entry === void 0 ? callMatcher(restMatcher, value, flags) : callMatcher(entry.matcher, value, flags);
+        if (r === void 0) {
+          if (output !== void 0 && issues === void 0) {
+            set(output, key, value);
+          }
+        } else if (!r.ok) {
+          issues = joinIssues(issues, prependPath(key, r));
+        } else if (issues === void 0) {
+          output ??= clone(obj, enumeratedBits, indexedBits);
+          set(output, key, r.value);
+        }
+        if (entry !== void 0) {
+          seenCount++;
+          enumeratedBits = setBit(enumeratedBits, entry.index);
+        }
+      }
+    }
+    if (seenCount < indexedEntries.length) {
+      for (let i = 0; i < indexedEntries.length; i++) {
+        if (getBit(enumeratedBits, i)) {
+          continue;
+        }
+        const entry = indexedEntries[i];
+        const value = obj[entry.key];
+        let extraFlags = 0;
+        if (value === void 0 && !(entry.key in obj)) {
+          if (!entry.optional) {
+            issues = joinIssues(issues, entry.missing);
+            continue;
+          }
+          extraFlags = FLAG_MISSING_VALUE;
+        }
+        const r = callMatcher(entry.matcher, value, flags | extraFlags);
+        if (r === void 0) {
+          if (output !== void 0 && issues === void 0 && !extraFlags) {
+            set(output, entry.key, value);
+          }
+        } else if (!r.ok) {
+          issues = joinIssues(issues, prependPath(entry.key, r));
+        } else if (issues === void 0) {
+          output ??= clone(obj, enumeratedBits, indexedBits);
+          set(output, entry.key, r.value);
+        }
+        if (extraFlags === 0) {
+          indexedBits = setBit(indexedBits, i);
+        }
+      }
+    }
+    if (unrecognized !== void 0) {
+      return joinIssues(issues, unrecognizedKeys(unrecognized));
+    } else if (issues !== void 0) {
+      return issues;
+    } else {
+      return output && { ok: true, value: output };
+    }
+  };
+}
+var ArrayOrTupleType = class _ArrayOrTupleType extends Type {
+  name = "array";
+  prefix;
+  restType;
+  suffix;
+  #matcher;
+  constructor(prefix, rest, suffix) {
+    super();
+    this.prefix = prefix;
+    this.restType = rest;
+    this.suffix = suffix;
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const prefix = this.prefix.map((t) => t[MATCHER_SYMBOL]);
+    const suffix = this.suffix.map((t) => t[MATCHER_SYMBOL]);
+    const rest = this.restType?.[MATCHER_SYMBOL] ?? taggedMatcher(1, () => ISSUE_MISSING_VALUE);
+    const minLength = prefix.length + suffix.length;
+    const maxLength = this.restType ? Infinity : minLength;
+    let message = `expected an array`;
+    if (minLength > 0) {
+      if (maxLength === minLength) {
+        message += `with ${minLength === 1 ? "item" : "items"}`;
+      } else if (maxLength < Infinity) {
+        message += `with between ${minLength} and ${maxLength} items`;
+      } else {
+        message += `with at least ${minLength === 1 ? "item" : "items"}`;
+      }
+    } else if (maxLength < Infinity) {
+      message += `with at most ${maxLength === 1 ? "item" : "items"}`;
+    }
+    const invalidLength = {
+      ok: false,
+      code: "invalid_length",
+      message,
+      minLength,
+      maxLength: maxLength === Infinity ? void 0 : maxLength
+    };
+    return this.#matcher = taggedMatcher(TAG_ARRAY, (arr, flags) => {
+      if (!Array.isArray(arr)) {
+        return ISSUE_EXPECTED_ARRAY;
+      }
+      const length = arr.length;
+      if (length < minLength || length > maxLength) {
+        return invalidLength;
+      }
+      const headEnd = prefix.length;
+      const tailStart = arr.length - suffix.length;
+      let issueTree = void 0;
+      let output = arr;
+      for (let i = 0; i < arr.length; i++) {
+        const entry = i < headEnd ? prefix[i] : i >= tailStart ? suffix[i - tailStart] : rest;
+        const r = callMatcher(entry, arr[i], flags);
+        if (r !== void 0) {
+          if (r.ok) {
+            if (output === arr) {
+              output = arr.slice();
+            }
+            output[i] = r.value;
+          } else {
+            issueTree = joinIssues(issueTree, prependPath(i, r));
+          }
+        }
+      }
+      if (issueTree) {
+        return issueTree;
+      } else if (arr === output) {
+        return void 0;
+      } else {
+        return { ok: true, value: output };
+      }
+    });
+  }
+  concat(type) {
+    if (this.restType) {
+      if (type.restType) {
+        throw new TypeError("can not concatenate two variadic types");
+      }
+      return new _ArrayOrTupleType(this.prefix, this.restType, [
+        ...this.suffix,
+        ...type.prefix,
+        ...type.suffix
+      ]);
+    } else if (type.restType) {
+      return new _ArrayOrTupleType([...this.prefix, ...this.suffix, ...type.prefix], type.restType, type.suffix);
+    } else {
+      return new _ArrayOrTupleType([...this.prefix, ...this.suffix, ...type.prefix, ...type.suffix], type.restType, type.suffix);
+    }
+  }
+};
+function toInputType(v) {
+  const type = typeof v;
+  if (type !== "object") {
+    return type;
+  } else if (v === null) {
+    return "null";
+  } else if (Array.isArray(v)) {
+    return "array";
+  } else {
+    return type;
+  }
+}
+function dedup(arr) {
+  return [...new Set(arr)];
+}
+function groupTerminals(terminals) {
+  const order = /* @__PURE__ */ new Map();
+  const literals = /* @__PURE__ */ new Map();
+  const types = /* @__PURE__ */ new Map();
+  const unknowns = [];
+  const optionals = [];
+  const expectedTypes = [];
+  for (const { root, terminal } of terminals) {
+    order.set(root, order.get(root) ?? order.size);
+    if (terminal.name === "never") {
+    } else if (terminal.name === "optional") {
+      optionals.push(root);
+    } else if (terminal.name === "unknown") {
+      unknowns.push(root);
+    } else if (terminal.name === "literal") {
+      const roots = literals.get(terminal.value) ?? [];
+      roots.push(root);
+      literals.set(terminal.value, roots);
+      expectedTypes.push(toInputType(terminal.value));
+    } else {
+      const roots = types.get(terminal.name) ?? [];
+      roots.push(root);
+      types.set(terminal.name, roots);
+      expectedTypes.push(terminal.name);
+    }
+  }
+  const byOrder = (a, b) => {
+    return (order.get(a) ?? 0) - (order.get(b) ?? 0);
+  };
+  for (const [value, roots] of literals) {
+    const options = types.get(toInputType(value));
+    if (options) {
+      options.push(...roots);
+      literals.delete(value);
+    } else {
+      literals.set(value, dedup(roots.concat(unknowns)).sort(byOrder));
+    }
+  }
+  for (const [type, roots] of types) {
+    types.set(type, dedup(roots.concat(unknowns)).sort(byOrder));
+  }
+  return {
+    types,
+    literals,
+    unknowns: dedup(unknowns).sort(byOrder),
+    optionals: dedup(optionals).sort(byOrder),
+    expectedTypes: dedup(expectedTypes)
+  };
+}
+function createObjectKeyMatcher(objects, key) {
+  const list = [];
+  for (const { root, terminal } of objects) {
+    terminal.shape[key]._toTerminals((t) => {
+      list.push({ root, terminal: t });
+    });
+  }
+  const { types, literals, optionals, unknowns, expectedTypes } = groupTerminals(list);
+  if (unknowns.length > 0 || optionals.length > 1) {
+    return void 0;
+  }
+  for (const roots of literals.values()) {
+    if (roots.length > 1) {
+      return void 0;
+    }
+  }
+  for (const roots of types.values()) {
+    if (roots.length > 1) {
+      return void 0;
+    }
+  }
+  const missingValue = prependPath(key, ISSUE_MISSING_VALUE);
+  const issue = prependPath(key, types.size === 0 ? expectedLiteral([...literals.keys()]) : expectedType(expectedTypes));
+  const byLiteral = literals.size > 0 ? /* @__PURE__ */ new Map() : void 0;
+  if (byLiteral) {
+    for (const [literal2, options] of literals) {
+      byLiteral.set(literal2, options[0][MATCHER_SYMBOL]);
+    }
+  }
+  const byType = types.size > 0 ? {} : void 0;
+  if (byType) {
+    for (const [type, options] of types) {
+      byType[type] = options[0][MATCHER_SYMBOL];
+    }
+  }
+  const optional = optionals[0]?.[MATCHER_SYMBOL];
+  return (obj, flags) => {
+    const value = obj[key];
+    if (value === void 0 && !(key in obj)) {
+      return optional === void 0 ? missingValue : callMatcher(optional, obj, flags);
+    }
+    const option = byType?.[toInputType(value)] ?? byLiteral?.get(value);
+    return option ? callMatcher(option, obj, flags) : issue;
+  };
+}
+function createUnionObjectMatcher(terminals) {
+  const objects = [];
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const { root, terminal } of terminals) {
+    if (terminal.name === "unknown") {
+      return void 0;
+    }
+    if (terminal.name === "object") {
+      for (const key in terminal.shape) {
+        keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+      }
+      objects.push({ root, terminal });
+    }
+  }
+  if (objects.length < 2) {
+    return void 0;
+  }
+  for (const [key, count] of keyCounts) {
+    if (count === objects.length) {
+      const matcher = createObjectKeyMatcher(objects, key);
+      if (matcher) {
+        return matcher;
+      }
+    }
+  }
+  return void 0;
+}
+function createUnionBaseMatcher(terminals) {
+  const { expectedTypes, literals, types, unknowns, optionals } = groupTerminals(terminals);
+  const issue = types.size === 0 && unknowns.length === 0 ? expectedLiteral([...literals.keys()]) : expectedType(expectedTypes);
+  const byLiteral = literals.size > 0 ? /* @__PURE__ */ new Map() : void 0;
+  if (byLiteral) {
+    for (const [literal2, options] of literals) {
+      byLiteral.set(literal2, options.map((t) => t[MATCHER_SYMBOL]));
+    }
+  }
+  const byType = types.size > 0 ? {} : void 0;
+  if (byType) {
+    for (const [type, options] of types) {
+      byType[type] = options.map((t) => t[MATCHER_SYMBOL]);
+    }
+  }
+  const optionalMatchers = optionals.map((t) => t[MATCHER_SYMBOL]);
+  const unknownMatchers = unknowns.map((t) => t[MATCHER_SYMBOL]);
+  return (value, flags) => {
+    const options = flags & FLAG_MISSING_VALUE ? optionalMatchers : byType?.[toInputType(value)] ?? byLiteral?.get(value) ?? unknownMatchers;
+    let count = 0;
+    let issueTree = issue;
+    for (let i = 0; i < options.length; i++) {
+      const r = callMatcher(options[i], value, flags);
+      if (r === void 0 || r.ok) {
+        return r;
+      }
+      issueTree = count > 0 ? joinIssues(issueTree, r) : r;
+      count++;
+    }
+    if (count > 1) {
+      return invalidUnion(issueTree);
+    }
+    return issueTree;
+  };
+}
+var UnionType = class extends Type {
+  name = "union";
+  options;
+  #matcher;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  _toTerminals(func) {
+    for (const option of this.options) {
+      option._toTerminals(func);
+    }
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const flattened = [];
+    for (const option of this.options) {
+      option._toTerminals((terminal) => {
+        flattened.push({ root: option, terminal });
+      });
+    }
+    const base = createUnionBaseMatcher(flattened);
+    const object2 = createUnionObjectMatcher(flattened);
+    return this.#matcher = taggedMatcher(TAG_UNION, (v, f) => object2 !== void 0 && isObject(v) ? object2(v, f) : base(v, f));
+  }
+};
+var STRICT = Object.freeze({ mode: "strict" });
+var STRIP = Object.freeze({ mode: "strip" });
+var PASSTHROUGH = Object.freeze({ mode: "passthrough" });
+function flagsToOptions(flags) {
+  return flags & FLAG_FORBID_EXTRA_KEYS ? STRICT : flags & FLAG_STRIP_EXTRA_KEYS ? STRIP : PASSTHROUGH;
+}
+var TransformType = class _TransformType extends Type {
+  name = "transform";
+  #transformed;
+  #transform;
+  #matcher;
+  constructor(transformed, transform) {
+    super();
+    this.#transformed = transformed;
+    this.#transform = transform;
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const chain = [];
+    let next = this;
+    while (next instanceof _TransformType) {
+      chain.push(next.#transform);
+      next = next.#transformed;
+    }
+    chain.reverse();
+    const matcher = next[MATCHER_SYMBOL];
+    const undef = ok(void 0);
+    return this.#matcher = taggedMatcher(TAG_TRANSFORM, (v, flags) => {
+      let result = callMatcher(matcher, v, flags);
+      if (result !== void 0 && !result.ok) {
+        return result;
+      }
+      let current;
+      if (result !== void 0) {
+        current = result.value;
+      } else if (flags & FLAG_MISSING_VALUE) {
+        current = void 0;
+        result = undef;
+      } else {
+        current = v;
+      }
+      for (let i = 0; i < chain.length; i++) {
+        const r = chain[i](current, flags);
+        if (r !== void 0) {
+          if (!r.ok) {
+            return r;
+          }
+          current = r.value;
+          result = r;
+        }
+      }
+      return result;
+    });
+  }
+  _toTerminals(func) {
+    this.#transformed._toTerminals(func);
+  }
+};
+var LazyType = class extends Type {
+  name = "lazy";
+  #definer;
+  #type;
+  #matcher;
+  #recursing = false;
+  constructor(definer) {
+    super();
+    this.#definer = definer;
+  }
+  get type() {
+    return this.#type ??= this.#definer();
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const matcher = taggedMatcher(TAG_OTHER, (value, flags) => {
+      const typeMatcher = this.type[MATCHER_SYMBOL];
+      matcher.tag = typeMatcher.tag;
+      matcher.match = typeMatcher.match;
+      this.#matcher = typeMatcher;
+      return callMatcher(typeMatcher, value, flags);
+    });
+    return this.#matcher = matcher;
+  }
+  _toTerminals(func) {
+    if (!this.#recursing) {
+      this.#recursing = true;
+      try {
+        this.type._toTerminals(func);
+      } finally {
+        this.#recursing = false;
+      }
+    }
+  }
+};
+function singleton(name, tag, match) {
+  const matcher = taggedMatcher(tag, match);
+  class SimpleType extends Type {
+    name;
+    constructor() {
+      super();
+      this.name = name;
+    }
+    get [MATCHER_SYMBOL]() {
+      return matcher;
+    }
+  }
+  const instance = new SimpleType();
+  return /* @__NO_SIDE_EFFECTS__ */ () => instance;
+}
+var unknown = /* @__PURE__ */ singleton("unknown", TAG_UNKNOWN, () => void 0);
+var string = /* @__PURE__ */ singleton("string", TAG_STRING, (v) => typeof v === "string" ? void 0 : ISSUE_EXPECTED_STRING);
+var number = /* @__PURE__ */ singleton("number", TAG_NUMBER, (v) => typeof v === "number" ? void 0 : ISSUE_EXPECTED_NUMBER);
+var boolean = /* @__PURE__ */ singleton("boolean", TAG_BOOLEAN, (v) => typeof v === "boolean" ? void 0 : ISSUE_EXPECTED_BOOLEAN);
+var null_ = /* @__PURE__ */ singleton("null", TAG_NULL, (v) => v === null ? void 0 : ISSUE_EXPECTED_NULL);
+var undefined_ = /* @__PURE__ */ singleton("undefined", TAG_UNDEFINED, (v) => v === void 0 ? void 0 : ISSUE_EXPECTED_UNDEFINED);
+var LiteralType = class extends Type {
+  name = "literal";
+  value;
+  #matcher;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  get [MATCHER_SYMBOL]() {
+    if (this.#matcher !== void 0) {
+      return this.#matcher;
+    }
+    const value = this.value;
+    const issue = expectedLiteral([value]);
+    return this.#matcher ??= taggedMatcher(TAG_LITERAL, (v) => v === value ? void 0 : issue);
+  }
+};
+var literal = (value) => {
+  return /* @__PURE__ */ new LiteralType(value);
+};
+var object = (obj) => {
+  return /* @__PURE__ */ new ObjectType(obj, void 0);
+};
+var record = (valueType) => {
+  return /* @__PURE__ */ new ObjectType({}, valueType ?? unknown());
+};
+var array = (item) => {
+  return /* @__PURE__ */ new ArrayOrTupleType([], item ?? unknown(), []);
+};
+var tuple = (items) => {
+  return /* @__PURE__ */ new ArrayOrTupleType(items, void 0, []);
+};
+var union = (...options) => {
+  return /* @__PURE__ */ new UnionType(options);
+};
+var lazy = (definer) => {
+  return new LazyType(definer);
+};
+
+// ../shared/src/valita.ts
+var STRICT2 = { mode: "strict" };
+function strict(schema) {
+  const type = unknown().chain((value) => schema.try(value, STRICT2));
+  return Object.assign(type, { strict: schema });
+}
+function readonly(t) {
+  return t;
+}
+function readonlyObject(t) {
+  return object(t);
+}
+function readonlyArray(t) {
+  return array(t);
+}
+function readonlyRecord(t) {
+  return record(t);
+}
+var AbstractType2 = Object.getPrototypeOf(
+  Object.getPrototypeOf(string().optional())
+).constructor;
+function literalUnion(...literals) {
+  return union(...literals.map(literal));
+}
+
+// ../shared/src/config.ts
+var isProd = process.env.NODE_ENV === "production";
+
+// ../shared/src/has-own.ts
+var { hasOwn } = Object;
+
+// ../shared/src/json.ts
+function isJSONValue(v, path2) {
+  switch (typeof v) {
+    case "boolean":
+    case "number":
+    case "string":
+      return true;
+    case "object":
+      if (v === null) {
+        return true;
+      }
+      if (Array.isArray(v)) {
+        return isJSONArray(v, path2);
+      }
+      return objectIsJSONObject(v, path2);
+  }
+  return false;
+}
+function isJSONObject(v, path2) {
+  if (typeof v !== "object" || v === null) {
+    return false;
+  }
+  return objectIsJSONObject(v, path2);
+}
+function objectIsJSONObject(v, path2) {
+  for (const k in v) {
+    if (hasOwn(v, k)) {
+      path2.push(k);
+      const value = v[k];
+      if (value !== void 0 && !isJSONValue(value, path2)) {
+        return false;
+      }
+      path2.pop();
+    }
+  }
+  return true;
+}
+function isJSONArray(v, path2) {
+  for (let i = 0; i < v.length; i++) {
+    path2.push(i);
+    if (!isJSONValue(v[i], path2)) {
+      return false;
+    }
+    path2.pop();
+  }
+  return true;
+}
+
+// ../shared/src/json-schema.ts
+var path = [];
+var jsonSchema = unknown().chain((v) => {
+  if (isProd) {
+    return ok(v);
+  }
+  const rv = isJSONValue(v, path) ? ok(v) : err({
+    message: `Not a JSON value`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
+var jsonObjectSchema = unknown().chain((v) => {
+  if (isProd) {
+    return ok(v);
+  }
+  const rv = isJSONObject(v, path) ? ok(v) : err({
+    message: `Not a JSON object`,
+    path: path.slice()
+  });
+  path.length = 0;
+  return rv;
+});
+
+// ../zero-protocol/src/data.ts
+var valueSchema = union(jsonSchema, undefined_());
+var rowSchema = readonlyRecord(valueSchema);
+
+// ../zero-protocol/src/ast.ts
+var selectorSchema = string();
+var orderingElementSchema = readonly(
+  tuple([selectorSchema, literalUnion("asc", "desc")])
+);
+var orderingSchema = readonlyArray(orderingElementSchema);
+var primitiveSchema = union(
+  string(),
+  number(),
+  boolean(),
+  null_()
+);
+var equalityOpsSchema = literalUnion("=", "!=", "IS", "IS NOT");
+var orderOpsSchema = literalUnion("<", ">", "<=", ">=");
+var likeOpsSchema = literalUnion(
+  "LIKE",
+  "NOT LIKE",
+  "ILIKE",
+  "NOT ILIKE"
+);
+var inOpsSchema = literalUnion("IN", "NOT IN");
+var simpleOperatorSchema = union(
+  equalityOpsSchema,
+  orderOpsSchema,
+  likeOpsSchema,
+  inOpsSchema
+);
+var literalReferenceSchema = readonlyObject({
+  type: literal("literal"),
+  value: union(
+    string(),
+    number(),
+    boolean(),
+    null_(),
+    readonlyArray(union(string(), number(), boolean()))
+  )
+});
+var columnReferenceSchema = readonlyObject({
+  type: literal("column"),
+  name: string()
+});
+var parameterReferenceSchema = readonlyObject({
+  type: 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: literalUnion("authData", "preMutationRow"),
+  field: union(string(), array(string()))
+});
+var conditionValueSchema = union(
+  literalReferenceSchema,
+  columnReferenceSchema,
+  parameterReferenceSchema
+);
+var simpleConditionSchema = readonlyObject({
+  type: literal("simple"),
+  op: simpleOperatorSchema,
+  left: conditionValueSchema,
+  right: union(parameterReferenceSchema, literalReferenceSchema)
+});
+var correlatedSubqueryConditionOperatorSchema = literalUnion("EXISTS", "NOT EXISTS");
+var correlatedSubqueryConditionSchema = readonlyObject({
+  type: literal("correlatedSubquery"),
+  related: lazy(() => correlatedSubquerySchema),
+  op: correlatedSubqueryConditionOperatorSchema,
+  flip: boolean().optional(),
+  scalar: boolean().optional()
+});
+var conditionSchema = union(
+  simpleConditionSchema,
+  lazy(() => conjunctionSchema),
+  lazy(() => disjunctionSchema),
+  correlatedSubqueryConditionSchema
+);
+var conjunctionSchema = readonlyObject({
+  type: literal("and"),
+  conditions: readonlyArray(conditionSchema)
+});
+var disjunctionSchema = readonlyObject({
+  type: literal("or"),
+  conditions: readonlyArray(conditionSchema)
+});
+var compoundKeySchema = readonly(
+  // oxlint-disable-next-line e18e/prefer-spread-syntax
+  tuple([string()]).concat(array(string()))
+);
+var correlationSchema = readonlyObject({
+  parentField: compoundKeySchema,
+  childField: compoundKeySchema
+});
+var correlatedSubquerySchemaOmitSubquery = readonlyObject({
+  correlation: correlationSchema,
+  hidden: boolean().optional(),
+  system: literalUnion("permissions", "client", "test").optional()
+});
+var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
+  subquery: lazy(() => astSchema)
+});
+var astSchema = readonlyObject({
+  schema: string().optional(),
+  table: string(),
+  alias: string().optional(),
+  where: conditionSchema.optional(),
+  related: readonlyArray(correlatedSubquerySchema).optional(),
+  limit: number().optional(),
+  orderBy: orderingSchema.optional(),
+  start: object({
+    row: rowSchema,
+    exclusive: boolean()
+  }).optional()
+});
+var MAX_AST_DEPTH = 50;
+function exceedsASTDepth(ast, maxDepth = MAX_AST_DEPTH) {
+  return astExceedsDepth(ast, 0, maxDepth);
+}
+function astExceedsDepth(ast, depth, maxDepth) {
+  if (depth > maxDepth) {
+    return true;
+  }
+  if (!isPlainObject(ast)) {
+    return false;
+  }
+  const { where, related } = ast;
+  return conditionExceedsDepth(where, depth, maxDepth) || Array.isArray(related) && related.some(
+    (r) => isPlainObject(r) && astExceedsDepth(r.subquery, depth + 1, maxDepth)
+  );
+}
+function conditionExceedsDepth(cond, depth, maxDepth) {
+  if (depth > maxDepth) {
+    return true;
+  }
+  if (!isPlainObject(cond)) {
+    return false;
+  }
+  const { conditions, related } = cond;
+  return Array.isArray(conditions) && conditions.some((c) => conditionExceedsDepth(c, depth + 1, maxDepth)) || isPlainObject(related) && astExceedsDepth(related.subquery, depth + 1, maxDepth);
+}
+var depthBoundedAstSchema = Object.assign(
+  unknown().chain(
+    (value, options) => exceedsASTDepth(value) ? err(`AST exceeds the maximum depth of ${MAX_AST_DEPTH}`) : astSchema.try(value, options)
+  ),
+  // A transform serializes as just its name. Show astSchema too, so a change
+  // to it still changes the hash in protocol-version.test.ts.
+  { depthBounded: astSchema }
+);
+var strictASTSchema = strict(depthBoundedAstSchema);
+function asNormalized(ast) {
+  return ast;
+}
+var normalizeCache = /* @__PURE__ */ new WeakMap();
+function normalizeAST(ast) {
+  return getOrInsertComputed(normalizeCache, ast, normalizeASTUncached);
+}
+function normalizeASTUncached(ast) {
+  const { where, related } = ast;
+  return normalizedAST({
+    ...ast,
+    where: where && normalizeSubqueries(where),
+    related: related?.map(
+      (r) => normalizedRelated({ ...r, subquery: normalizeAST(r.subquery) })
+    )
+  });
+}
+function normalizeSubqueries(cond) {
+  switch (cond.type) {
+    case "simple":
+      return cond;
+    case "correlatedSubquery":
+      return {
+        ...cond,
+        related: {
+          ...cond.related,
+          subquery: normalizeAST(cond.related.subquery)
+        }
+      };
+    default:
+      return {
+        type: cond.type,
+        conditions: cond.conditions.map(normalizeSubqueries)
+      };
+  }
+}
+function normalizedAST(ast) {
+  const { schema, table, alias, where, related, start, limit, orderBy } = ast;
+  return asNormalized({
+    schema,
+    table,
+    alias,
+    where: where === void 0 ? void 0 : normalizeCondition(where),
+    related: related === void 0 ? void 0 : normalizeRelated(related),
+    start,
+    limit,
+    orderBy
+  });
+}
+var normalizedConditions = /* @__PURE__ */ new WeakSet();
+function normalizeRelated(related) {
+  for (let i = 1; i < related.length; i++) {
+    if (cmpRelated(related[i - 1], related[i]) > 0) {
+      return related.toSorted(cmpRelated);
+    }
+  }
+  return related;
+}
+function normalizedRelated(related) {
+  const { correlation, hidden, subquery, system } = related;
+  return {
+    correlation: {
+      parentField: correlation.parentField,
+      childField: correlation.childField
+    },
+    hidden,
+    subquery,
+    system
+  };
+}
+function normalizeValuePosition(v) {
+  switch (v.type) {
+    case "literal":
+      return { type: "literal", value: v.value };
+    case "column":
+      return { type: "column", name: v.name };
+    default:
+      return { type: "static", anchor: v.anchor, field: v.field };
+  }
+}
+function normalizeCondition(cond) {
+  if (normalizedConditions.has(cond)) {
+    return cond;
+  }
+  if (cond.type === "simple") {
+    const normalized2 = {
+      type: "simple",
+      op: cond.op,
+      left: normalizeValuePosition(cond.left),
+      right: normalizeValuePosition(cond.right)
+    };
+    normalizedConditions.add(normalized2);
+    return normalized2;
+  }
+  if (cond.type === "correlatedSubquery") {
+    const normalized2 = {
+      type: "correlatedSubquery",
+      related: normalizedRelated(cond.related),
+      op: cond.op,
+      flip: cond.flip,
+      scalar: cond.scalar
+    };
+    normalizedConditions.add(normalized2);
+    return normalized2;
+  }
+  const conditions = [];
+  for (const c of cond.conditions) {
+    const n = normalizeCondition(c);
+    if (n.type === cond.type) {
+      conditions.push(...n.conditions);
+    } else {
+      conditions.push(n);
+    }
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  conditions.sort(cmpCondition);
+  const normalized = { type: cond.type, conditions };
+  normalizedConditions.add(normalized);
+  return normalized;
+}
+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) || cmpOptionalBool(a.flip, b.flip) || cmpOptionalBool(a.scalar, b.scalar);
+  }
+  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", "Expected literal type for comparison");
+      return cmpLiteralValue(a.value, b.value);
+    case "column":
+      assert(b.type === "column", "Expected column type for comparison");
+      return compareUTF8(a.name, b.name);
+    case "static":
+      assert(b.type === "static", "Expected static type for comparison");
+      return compareUTF8(a.anchor, b.anchor) || cmpLiteralValue(a.field, b.field);
+  }
+}
+var LITERAL_VALUE_TYPES = ["object", "boolean", "number", "string"];
+function literalValueType(value) {
+  return Array.isArray(value) ? LITERAL_VALUE_TYPES.length : LITERAL_VALUE_TYPES.indexOf(typeof value);
+}
+function cmpLiteralValue(a, b) {
+  const type = literalValueType(a) - literalValueType(b);
+  if (type !== 0) {
+    return type;
+  }
+  if (Array.isArray(a)) {
+    assert(Array.isArray(b), "Expected array for comparison");
+    for (let i = 0; i < a.length && i < b.length; i++) {
+      const val = cmpLiteralValue(a[i], b[i]);
+      if (val !== 0) {
+        return val;
+      }
+    }
+    return a.length - b.length;
+  }
+  switch (typeof a) {
+    case "string":
+      assert(typeof b === "string", "Expected string for comparison");
+      return compareUTF8(a, b);
+    case "number":
+      assert(typeof b === "number", "Expected number for comparison");
+      return a < b ? -1 : a > b ? 1 : 0;
+    case "boolean":
+      assert(typeof b === "boolean", "Expected boolean for comparison");
+      return Number(a) - Number(b);
+    default:
+      return 0;
+  }
+}
+function cmpRelated(a, b) {
+  return compareUTF8(must(a.subquery.alias), must(b.subquery.alias));
+}
+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;
+}
+function cmpOptionalBool(a, b) {
+  const toNum = (v) => v === void 0 ? 0 : v ? 2 : 1;
+  return toNum(a) - toNum(b);
+}
+
+// ../shared/src/xxhash32.ts
+var PRIME32_1 = 2654435761;
+var PRIME32_2 = 2246822519;
+var PRIME32_3 = 3266489917;
+var PRIME32_5 = 374761393;
+function round32(acc, word) {
+  acc = acc + Math.imul(word, PRIME32_2) | 0;
+  acc = acc << 13 | acc >>> 19;
+  return Math.imul(acc, PRIME32_1);
+}
+function avalanche32(acc) {
+  acc ^= acc >>> 15;
+  acc = Math.imul(acc, PRIME32_2);
+  acc ^= acc >>> 13;
+  acc = Math.imul(acc, PRIME32_3);
+  acc ^= acc >>> 16;
+  return acc >>> 0;
+}
+
+// ../shared/src/hash.ts
+var MAX_WORDS = 4;
+var accs = new Int32Array(MAX_WORDS);
+var stripes = new Int32Array(MAX_WORDS * 4);
+var digests = new Uint32Array(MAX_WORDS);
+var wideView = new DataView(new ArrayBuffer(16));
+
+// ../zero-protocol/src/query-hash-visitor.ts
+var h1 = 0;
+var h2 = 0;
+function mix(w) {
+  h1 = round32(h1, w);
+  h2 = round32(h2, w);
+}
+function mixString(s) {
+  const n = s.length;
+  mix(n | STR_MARK);
+  let i = 0;
+  for (; i + 1 < n; i += 2) {
+    mix(s.charCodeAt(i) | s.charCodeAt(i + 1) << 16);
+  }
+  if (i < n) {
+    mix(s.charCodeAt(i));
+  }
+}
+var numView = new DataView(new ArrayBuffer(8));
+function mixNumber(n) {
+  if ((n | 0) === n) {
+    mix(n);
+  } else {
+    numView.setFloat64(0, n, true);
+    mix(numView.getInt32(0, true));
+    mix(numView.getInt32(4, true));
+  }
+}
+var TAG_NULL2 = 4097;
+var TAG_FALSE = 4098;
+var TAG_TRUE = 4099;
+var TAG_INT = 4100;
+var TAG_FLOAT = 4101;
+var TAG_ARR = 4103;
+var TAG_OBJ = 4104;
+var TAG_END = 4105;
+var TAG_UNDEF = 4106;
+var TAG_LITERAL2 = 8193;
+var TAG_COLUMN = 8194;
+var TAG_STATIC = 8195;
+var TAG_SIMPLE = 8196;
+var TAG_SUBQUERY = 8197;
+var TAG_AND = 8198;
+var TAG_OR = 8199;
+var TAG_SYSTEM_PERMISSIONS = 8202;
+var TAG_SYSTEM_CLIENT = 8203;
+var TAG_SYSTEM_TEST = 8204;
+var STR_MARK = 1073741824;
+function reset() {
+  h1 = PRIME32_5;
+  h2 = PRIME32_1;
+}
+function finalize() {
+  return avalanche32(h1).toString(36).padStart(7, "0") + avalanche32(h2).toString(36).padStart(7, "0");
+}
+function visitValue(v) {
+  switch (typeof v) {
+    case "string":
+      mixString(v);
+      return;
+    case "number":
+      if (!Number.isFinite(v)) {
+        mix(TAG_NULL2);
+        return;
+      }
+      mix((v | 0) === v ? TAG_INT : TAG_FLOAT);
+      mixNumber(v);
+      return;
+    case "boolean":
+      mix(v ? TAG_TRUE : TAG_FALSE);
+      return;
+    case "object": {
+      if (v === null) {
+        mix(TAG_NULL2);
+        return;
+      }
+      if (Array.isArray(v)) {
+        mix(TAG_ARR);
+        for (let i = 0; i < v.length; i++) {
+          const e = v[i];
+          visitValue(e === void 0 ? null : e);
+        }
+        mix(TAG_END);
+        return;
+      }
+      mix(TAG_OBJ);
+      const keys = Object.keys(v).sort();
+      for (const k of keys) {
+        const val = v[k];
+        if (val === void 0) {
+          continue;
+        }
+        mixString(k);
+        visitValue(val);
+      }
+      mix(TAG_END);
+      return;
+    }
+    default:
+      return;
+  }
+}
+function visitOptionalString(s) {
+  if (s === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    mixString(s);
+  }
+}
+function mixOptionalSystem(system) {
+  if (system === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    mixSystem(system);
+  }
+}
+function mixSystem(system) {
+  switch (system) {
+    case "permissions":
+      mix(TAG_SYSTEM_PERMISSIONS);
+      break;
+    case "client":
+      mix(TAG_SYSTEM_CLIENT);
+      break;
+    case "test":
+      mix(TAG_SYSTEM_TEST);
+      break;
+    default:
+      unreachable(system);
+  }
+}
+function visitCompoundKey(k) {
+  mix(k.length);
+  for (let i = 0; i < k.length; i++) {
+    mixString(k[i]);
+  }
+}
+function visitOrdering(o) {
+  if (o === void 0) {
+    mix(TAG_UNDEF);
+    return;
+  }
+  mix(o.length);
+  for (let i = 0; i < o.length; i++) {
+    const [field, dir] = o[i];
+    mixString(field);
+    mix(dir === "asc" ? TAG_TRUE : TAG_FALSE);
+  }
+}
+function visitValuePosition(v) {
+  switch (v.type) {
+    case "literal":
+      mix(TAG_LITERAL2);
+      visitValue(v.value);
+      return;
+    case "column":
+      mix(TAG_COLUMN);
+      mixString(v.name);
+      return;
+    case "static": {
+      mix(TAG_STATIC);
+      mixString(v.anchor);
+      if (typeof v.field === "string") {
+        mixString(v.field);
+      } else {
+        visitCompoundKey(v.field);
+      }
+      return;
+    }
+    default:
+      unreachable(v);
+  }
+}
+function visitCondition(c) {
+  switch (c.type) {
+    case "simple":
+      mix(TAG_SIMPLE);
+      mixString(c.op);
+      visitValuePosition(c.left);
+      visitValuePosition(c.right);
+      return;
+    case "correlatedSubquery":
+      mix(TAG_SUBQUERY);
+      mixString(c.op);
+      mix(c.flip === void 0 ? TAG_UNDEF : c.flip ? TAG_TRUE : TAG_FALSE);
+      mix(c.scalar === void 0 ? TAG_UNDEF : c.scalar ? TAG_TRUE : TAG_FALSE);
+      visitCorrelatedSubquery(c.related);
+      return;
+    default: {
+      c.type;
+      mix(c.type === "and" ? TAG_AND : TAG_OR);
+      const conds = c.conditions;
+      mix(conds.length);
+      for (let i = 0; i < conds.length; i++) {
+        visitCondition(conds[i]);
+      }
+      return;
+    }
+  }
+}
+function visitCorrelatedSubquery(csq) {
+  visitCompoundKey(csq.correlation.parentField);
+  visitCompoundKey(csq.correlation.childField);
+  mix(csq.hidden === void 0 ? TAG_UNDEF : csq.hidden ? TAG_TRUE : TAG_FALSE);
+  mixOptionalSystem(csq.system);
+  visitAST(csq.subquery);
+}
+function visitAST(ast) {
+  mix(TAG_OBJ);
+  visitOptionalString(ast.schema);
+  mixString(ast.table);
+  visitOptionalString(ast.alias);
+  if (ast.where === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    visitCondition(ast.where);
+  }
+  const related = ast.related;
+  if (related === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    mix(related.length);
+    for (let i = 0; i < related.length; i++) {
+      visitCorrelatedSubquery(related[i]);
+    }
+  }
+  const start = ast.start;
+  if (start === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    mix(start.exclusive ? TAG_TRUE : TAG_FALSE);
+    visitValue(start.row);
+  }
+  if (ast.limit === void 0) {
+    mix(TAG_UNDEF);
+  } else {
+    mix(TAG_INT);
+    mixNumber(ast.limit);
+  }
+  visitOrdering(ast.orderBy);
+  mix(TAG_END);
+}
+function hashAST(ast) {
+  const s1 = h1;
+  const s2 = h2;
+  try {
+    reset();
+    visitAST(ast);
+    return finalize();
+  } finally {
+    h1 = s1;
+    h2 = s2;
+  }
+}
+
+// ../zero-protocol/src/query-hash.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
+function hashOfAST(ast) {
+  return hashOfNormalizedAST(normalizeAST(ast));
+}
+function hashOfNormalizedAST(ast) {
+  return getOrInsertComputed(hashCache, ast, hashAST);
+}
+
+// src/drift.ts
+var seedName = "__drift.seed";
+var dayMs = 24 * 60 * 60 * 1e3;
+var offlineWarning = "Zero starting up with no server URL. No data will be synced.";
+async function recordDriftFile(path2) {
+  const module = await import(pathToFileURL(path2).href);
+  if (!module.default?.querySamples || !module.default.mutatorSamples) {
+    throw new Error(`${path2} does not export drift samples by default`);
+  }
+  return recordDrift(module.default);
+}
+async function recordDrift(samples) {
+  const { schema, queries, mutators } = samples;
+  const querySamples = samples.querySamples.map((sample) => {
+    const query = mustGetQuery(queries, sample.name);
+    const { ast } = query.fn({
+      args: sample.args,
+      ctx: sample.context
+    });
+    return {
+      name: sample.name,
+      args: sample.args === void 0 ? [] : [sample.args],
+      context: sample.context ?? null,
+      ast: json(ast),
+      hash: hashOfAST(ast)
+    };
+  });
+  const mutatorSamples = [];
+  const { warn } = console;
+  console.warn = (...args) => {
+    if (args[0] !== offlineWarning) warn(...args);
+  };
+  try {
+    for (const [i, sample] of samples.mutatorSamples.entries()) {
+      const result = await runMutator(schema, mutators, sample, 0);
+      const again = await runMutator(schema, mutators, sample, dayMs);
+      if (JSON.stringify(again) !== JSON.stringify(result)) {
+        throw new Error(
+          `mutator ${sample.name} sample ${i} does something else when run again a day later. Pass IDs and timestamps as arguments.`
+        );
+      }
+      mutatorSamples.push({
+        ...sample,
+        context: sample.context ?? null,
+        seed: sample.seed ?? {},
+        ...result
+      });
+    }
+  } finally {
+    console.warn = warn;
+  }
+  const vectors = {
+    queries: names(queries, isQuery, (q) => q.queryName),
+    mutators: names(mutators, isMutator, (m) => m.mutatorName),
+    querySamples,
+    mutatorSamples
+  };
+  return JSON.stringify(vectors, null, 2) + "\n";
+}
+async function seed({
+  tx,
+  args
+}) {
+  for (const [table, rows2] of Object.entries(args)) {
+    for (const row of rows2) {
+      await tx.mutate[table].upsert(row);
+    }
+  }
+}
+async function runMutator(schema, mutators, sample, shiftMs) {
+  const registry = defineMutators(mutators, {
+    __drift: { seed: defineMutator(seed) }
+  });
+  const zero = new Zero({
+    schema,
+    mutators: registry,
+    userID: "drift",
+    storageKey: `drift-${Math.random().toString(36).slice(2)}`,
+    kvStore: "mem",
+    context: sample.context,
+    // The mutators' errors are what the samples record, not news.
+    logSink: { log() {
+    } }
+  });
+  try {
+    const call = (name, args) => zero.mutate(
+      mustGetMutator(registry, name)(...args === void 0 ? [] : [args])
+    );
+    await call(seedName, sample.seed ?? {}).client;
+    const before = await rows(zero, schema);
+    const { now } = Date;
+    Date.now = () => now() + shiftMs;
+    let outcome;
+    try {
+      outcome = await call(sample.name, sample.args).client;
+    } finally {
+      Date.now = now;
+    }
+    const after = await rows(zero, schema);
+    return { outcome: json(outcome), changes: diff(schema, before, after) };
+  } finally {
+    await zero.close();
+  }
+}
+async function rows(zero, schema) {
+  const builder = createBuilder(schema);
+  const out = /* @__PURE__ */ new Map();
+  for (const [table, { primaryKey }] of Object.entries(schema.tables)) {
+    const data = await zero.run(builder[table]);
+    out.set(
+      table,
+      new Map(
+        data.map((row) => [
+          JSON.stringify(primaryKey.map((c) => row[c] ?? null)),
+          json(row)
+        ])
+      )
+    );
+  }
+  return out;
+}
+function diff(schema, before, after) {
+  const changes = [];
+  for (const [table, { primaryKey }] of Object.entries(schema.tables)) {
+    const old = before.get(table) ?? /* @__PURE__ */ new Map();
+    const now = after.get(table) ?? /* @__PURE__ */ new Map();
+    const keys = [.../* @__PURE__ */ new Set([...old.keys(), ...now.keys()])].toSorted(
+      (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b))
+    );
+    for (const key of keys) {
+      const o = old.get(key);
+      const n = now.get(key);
+      if (n !== void 0) {
+        if (o === void 0 || !sameJSON(o, n)) {
+          changes.push({ table, op: "put", row: n });
+        }
+      } else if (o !== void 0) {
+        changes.push({
+          table,
+          op: "del",
+          id: Object.fromEntries(primaryKey.map((c) => [c, o[c] ?? null]))
+        });
+      }
+    }
+  }
+  return changes;
+}
+function sameJSON(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => sameJSON(v, b[i]));
+  }
+  const ak = Object.keys(a);
+  const bo = b;
+  return ak.length === Object.keys(b).length && ak.every(
+    (k) => k in bo && sameJSON(a[k], bo[k])
+  );
+}
+function names(registry, isLeaf, name) {
+  const out = [];
+  const walk = (node) => {
+    if (isLeaf(node)) {
+      out.push(name(node));
+    } else if (node && typeof node === "object") {
+      for (const [key, child] of Object.entries(node)) {
+        if (key !== "~") walk(child);
+      }
+    }
+  };
+  walk(registry);
+  return out.sort();
+}
+function json(v) {
+  return v === void 0 ? null : JSON.parse(JSON.stringify(v));
+}
+export {
+  recordDrift,
+  recordDriftFile
+};