@rocicorp/zero 0.11.2025011402 → 0.11.2025011801

package/out/{chunk-AII6TS5B.js → chunk-QV5ZN4MA.js}

@@ -1311,7 +1311,7 @@ function* joinIterables(...iters) {
     yield* iter;
   }
 }
-function* mergeIterables(iterables, comparator, distinct = false) {
+function* mergeIterables(iterables, comparator2, distinct = false) {
   const iterators = iterables.map((i) => i[Symbol.iterator]());
   try {
     const current = iterators.map((i) => i.next());
@@ -1322,7 +1322,7 @@ function* mergeIterables(iterables, comparator, distinct = false) {
           if (c.done) {
             return acc;
           }
-          if (acc === void 0 || comparator(c.value, acc[0]) < 0) {
+          if (acc === void 0 || comparator2(c.value, acc[0]) < 0) {
             return [c.value, i];
           }
           return acc;
@@ -1331,7 +1331,7 @@ function* mergeIterables(iterables, comparator, distinct = false) {
       );
       assert(min !== void 0, "min is undefined");
       current[min[1]] = iterators[min[1]].next();
-      if (lastYielded !== void 0 && distinct && comparator(lastYielded, min[0]) === 0) {
+      if (lastYielded !== void 0 && distinct && comparator2(lastYielded, min[0]) === 0) {
         continue;
       }
       lastYielded = min[0];
@@ -8320,312 +8320,6 @@ function getKVStoreProvider(lc, kvStore) {
 // ../replicache/src/mod.ts
 import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
 
-// ../zero-schema/src/column.ts
-var column_exports = {};
-__export(column_exports, {
-  boolean: () => boolean3,
-  enumeration: () => enumeration,
-  json: () => json,
-  number: () => number4,
-  string: () => string7
-});
-function string7(optional) {
-  return {
-    type: "string",
-    optional: optional ?? false,
-    customType: null
-  };
-}
-function number4(optional) {
-  return {
-    type: "number",
-    optional: optional ?? false,
-    customType: null
-  };
-}
-function boolean3(optional) {
-  return {
-    type: "boolean",
-    optional: optional ?? false,
-    customType: null
-  };
-}
-function json(optional) {
-  return {
-    type: "json",
-    optional: optional ?? false,
-    customType: null
-  };
-}
-function enumeration(optional) {
-  return {
-    type: "string",
-    kind: "enum",
-    customType: null,
-    optional: optional ?? false
-  };
-}
-
-// ../zero-schema/src/table-schema.ts
-function createTableSchema(schema) {
-  return schema;
-}
-function isFieldRelationship(relationship) {
-  return !isJunctionRelationship(relationship);
-}
-function isJunctionRelationship(relationship) {
-  return Array.isArray(relationship);
-}
-
-// ../shared/src/sorted-entries.ts
-function sortedEntries(object18) {
-  return Object.entries(object18).sort((a, b) => stringCompare(a[0], b[0]));
-}
-
-// ../zero-schema/src/normalize-table-schema.ts
-var NormalizedTableSchema = class {
-  tableName;
-  primaryKey;
-  columns;
-  relationships;
-  constructor(tableSchema, tableSchemaCache, assertFieldRelation) {
-    this.tableName = tableSchema.tableName;
-    const primaryKey = normalizePrimaryKey(tableSchema.primaryKey);
-    this.primaryKey = primaryKey;
-    this.columns = normalizeColumns(tableSchema.columns, primaryKey);
-    tableSchemaCache.set(tableSchema, this);
-    this.relationships = normalizeRelationships(
-      this.tableName,
-      tableSchema.relationships,
-      tableSchemaCache,
-      assertFieldRelation
-    );
-  }
-};
-var noop3 = () => {
-};
-function normalizeTableSchema(tableSchema) {
-  return normalizeTableSchemaWithCache(
-    tableSchema,
-    tableSchema.tableName,
-    /* @__PURE__ */ new Map(),
-    noop3
-  );
-}
-function normalizeTableSchemaWithCache(tableSchema, expectedTableName, tableSchemaCache, assertFieldRelation) {
-  if (tableSchema instanceof NormalizedTableSchema) {
-    return tableSchema;
-  }
-  assert(
-    tableSchema.tableName === expectedTableName,
-    `Table name mismatch: "${tableSchema.tableName}" !== "${expectedTableName}"`
-  );
-  let normalizedTableSchema = tableSchemaCache.get(tableSchema);
-  if (normalizedTableSchema) {
-    return normalizedTableSchema;
-  }
-  normalizedTableSchema = new NormalizedTableSchema(
-    tableSchema,
-    tableSchemaCache,
-    assertFieldRelation
-  );
-  return normalizedTableSchema;
-}
-function assertNoDuplicates(arr) {
-  assert(
-    new Set(arr).size === arr.length,
-    "Primary key must not contain duplicates"
-  );
-}
-function normalizePrimaryKey(primaryKey) {
-  if (typeof primaryKey === "string") {
-    return [primaryKey];
-  }
-  assertNoDuplicates(primaryKey);
-  return primaryKey;
-}
-function normalizeColumns(columns, primaryKey) {
-  const rv = {};
-  for (const pk of primaryKey) {
-    const schemaValue = columns[pk];
-    assert(schemaValue, `Primary key column "${pk}" not found`);
-    if (typeof schemaValue !== "string") {
-      const { type, optional } = schemaValue;
-      assert(!optional, `Primary key column "${pk}" cannot be optional`);
-      assert(
-        type === "string" || type === "number" || type === "boolean",
-        `Primary key column "${pk}" must be a string, number, or boolean. Got ${type}`
-      );
-    }
-  }
-  for (const [name, column] of sortedEntries(columns)) {
-    rv[name] = normalizeColumn(column);
-  }
-  return rv;
-}
-function normalizeColumn(value) {
-  if (typeof value === "string") {
-    return { type: value, optional: false };
-  }
-  return {
-    type: value.type,
-    optional: value.optional ?? false
-  };
-}
-function normalizeRelationships(tableName, relationships, tableSchemaCache, assertFieldRelation) {
-  const rv = {};
-  if (relationships) {
-    for (const [relationshipName, relationship] of sortedEntries(
-      relationships
-    )) {
-      rv[relationshipName] = normalizeRelationship(
-        tableName,
-        relationshipName,
-        relationship,
-        tableSchemaCache,
-        assertFieldRelation
-      );
-    }
-  }
-  return rv;
-}
-function normalizeRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
-  if (isFieldRelationship(relationship)) {
-    return normalizeFieldRelationship(
-      tableName,
-      relationshipName,
-      relationship,
-      tableSchemaCache,
-      assertFieldRelation
-    );
-  }
-  return normalizeJunctionRelationship(
-    tableName,
-    relationshipName,
-    relationship,
-    tableSchemaCache,
-    assertFieldRelation
-  );
-}
-function normalizeFieldRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
-  const sourceField = normalizeFieldName(relationship.sourceField);
-  const destField = normalizeFieldName(relationship.destField);
-  assert(
-    sourceField.length === destField.length,
-    "Source and destination fields must have the same length"
-  );
-  const destSchema = normalizeLazyTableSchema(
-    relationship.destSchema,
-    tableSchemaCache,
-    assertFieldRelation
-  );
-  const normalized = {
-    sourceField,
-    destField,
-    destSchema
-  };
-  assertFieldRelation(tableName, relationshipName, normalized);
-  return normalized;
-}
-function normalizeJunctionRelationship(tableName, relationshipName, relationship, tableSchemaCache, assertFieldRelation) {
-  const first2 = normalizeFieldRelationship(
-    tableName,
-    relationshipName,
-    relationship[0],
-    tableSchemaCache,
-    assertFieldRelation
-  );
-  const second = normalizeFieldRelationship(
-    first2.destSchema.tableName,
-    relationshipName,
-    relationship[1],
-    tableSchemaCache,
-    assertFieldRelation
-  );
-  return [first2, second];
-}
-function normalizeLazyTableSchema(tableSchema, buildCache, assertFieldRelation) {
-  const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
-  return normalizeTableSchemaWithCache(
-    tableSchemaInstance,
-    tableSchemaInstance.tableName,
-    // Don't care about name here.
-    buildCache,
-    assertFieldRelation
-  );
-}
-function normalizeFieldName(sourceField) {
-  if (typeof sourceField === "string") {
-    return [sourceField];
-  }
-  assert(sourceField.length > 0, "Expected at least one field");
-  return sourceField;
-}
-function normalizeTables(tables) {
-  const result = {};
-  const assertFieldRelation = (tableName) => tableName in tables;
-  for (const [name, table] of sortedEntries(tables)) {
-    result[name] = normalizeTableSchemaWithCache(
-      table,
-      name,
-      /* @__PURE__ */ new Map(),
-      assertFieldRelation
-    );
-  }
-  return result;
-}
-
-// ../zero-schema/src/normalized-schema.ts
-var normalizedCache = /* @__PURE__ */ new WeakMap();
-function normalizeSchema(schema) {
-  if (schema instanceof NormalizedSchema) {
-    return schema;
-  }
-  let s;
-  if (!(s = normalizedCache.get(schema))) {
-    normalizedCache.set(schema, s = new NormalizedSchema(schema));
-  }
-  return s;
-}
-var NormalizedSchema = class {
-  version;
-  tables;
-  constructor(schema) {
-    this.version = schema.version;
-    this.tables = normalizeTables2(schema.tables);
-  }
-};
-function normalizeTables2(tables) {
-  const rv = {};
-  const tableSchemaCache = /* @__PURE__ */ new Map();
-  function assertFieldRelation(tableName, relationShipName, relation) {
-    const destTableName = relation.destSchema.tableName;
-    assert(
-      destTableName in tables,
-      `Relationship "${tableName}"."${relationShipName}" destination "${destTableName}" is missing in schema`
-    );
-    assertColumns(relation.sourceField, tables[tableName]);
-    assertColumns(relation.destField, tables[destTableName]);
-  }
-  function assertColumns(columnNames, table) {
-    for (const columnName of columnNames) {
-      assert(
-        columnName in table.columns,
-        `Column "${columnName}" is missing in table "${table.tableName}"`
-      );
-    }
-  }
-  for (const [name, table] of sortedEntries(tables)) {
-    rv[name] = normalizeTableSchemaWithCache(
-      table,
-      name,
-      tableSchemaCache,
-      assertFieldRelation
-    );
-  }
-  return rv;
-}
-
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
 
@@ -9077,6 +8771,14 @@ function hashOfAST(ast) {
   return hash2;
 }
 
+// ../zero-schema/src/table-schema.ts
+function isOneHop(r) {
+  return r.length === 1;
+}
+function isTwoHop(r) {
+  return r.length === 2;
+}
+
 // ../zql/src/ivm/change.ts
 function rowForChange(change) {
   const { type } = change;
@@ -9134,6 +8836,13 @@ function valuesEqual(a, b) {
   return a === b;
 }
 
+// ../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) {
@@ -9162,7 +8871,7 @@ var Exists = class {
   #not;
   #parentJoinKey;
   #skipCache;
-  #output;
+  #output = throwOutput;
   constructor(input, storage, relationshipName, parentJoinKey, type) {
     this.#input = input;
     this.#relationshipName = relationshipName;
@@ -9201,7 +8910,6 @@ var Exists = class {
     }
   }
   push(change) {
-    assert(this.#output, "Output not set");
     switch (change.type) {
       case "add":
       case "edit": {
@@ -9296,7 +9004,7 @@ var Exists = class {
   #pushWithFilter(change, size) {
     const row = rowForChange(change);
     if (this.#filter(row, size)) {
-      must(this.#output).push(change);
+      this.#output.push(change);
     }
   }
   #getSize(row) {
@@ -9389,7 +9097,7 @@ var FanIn = class {
   #inputs;
   #fanOut;
   #schema;
-  #output;
+  #output = throwOutput;
   constructor(fanOut, inputs) {
     this.#inputs = inputs;
     this.#schema = fanOut.getSchema();
@@ -9426,7 +9134,7 @@ var FanIn = class {
   }
   push(change) {
     this.#fanOut.onFanInReceivedPush();
-    this.#output?.push(change);
+    this.#output.push(change);
   }
 };
 
@@ -9504,7 +9212,7 @@ var Filter = class {
   #input;
   #mode;
   #predicate;
-  #output;
+  #output = throwOutput;
   constructor(input, mode, predicate) {
     this.#input = input;
     this.#mode = mode;
@@ -9534,7 +9242,6 @@ var Filter = class {
     }
   }
   push(change) {
-    assert(this.#output, "Output not set");
     switch (change.type) {
       case "add":
       case "remove":
@@ -9565,7 +9272,7 @@ var Join = class {
   #childKey;
   #relationshipName;
   #schema;
-  #output = null;
+  #output = throwOutput;
   constructor({
     parent,
     child,
@@ -9636,7 +9343,6 @@ var Join = class {
     }
   }
   #pushParent(change) {
-    assert(this.#output, "Output not set");
     switch (change.type) {
       case "add":
         this.#output.push({
@@ -9698,7 +9404,6 @@ var Join = class {
   }
   #pushChild(change) {
     const pushChildChange = (childRow, change2) => {
-      assert(this.#output, "Output not set");
       const parentNodes = this.#parent.fetch({
         constraint: Object.fromEntries(
           this.#parentKey.map((key, i) => [key, childRow[this.#childKey[i]]])
@@ -9812,7 +9517,7 @@ var Skip = class {
   #input;
   #bound;
   #comparator;
-  #output;
+  #output = throwOutput;
   constructor(input, bound) {
     this.#input = input;
     this.#bound = bound;
@@ -9856,7 +9561,6 @@ var Skip = class {
     return cmp2 < 0 || cmp2 === 0 && !this.#bound.exclusive;
   }
   push(change) {
-    assert(this.#output, "Output not set");
     const shouldBePresent = (row) => this.#shouldBePresent(row);
     if (change.type === "edit") {
       maybeSplitAndPushEditChange(change, shouldBePresent, this.#output);
@@ -9917,7 +9621,7 @@ var Take = class {
   #limit;
   #partitionKey;
   #partitionKeyComparator;
-  #output = null;
+  #output = throwOutput;
   constructor(input, storage, limit, partitionKey) {
     assert(limit >= 0);
     assertOrderingIncludesPK(
@@ -10044,7 +9748,6 @@ var Take = class {
       this.#pushEditChange(change);
       return;
     }
-    assert(this.#output, "Output not set");
     const { takeState, takeStateKey, maxBound, constraint } = this.#getStateAndConstraint(rowForChange(change));
     if (!takeState) {
       return;
@@ -10176,7 +9879,6 @@ var Take = class {
     }
   }
   #pushEditChange(change) {
-    assert(this.#output, "Output not set");
     if (this.#partitionKeyComparator && this.#partitionKeyComparator(change.oldNode.row, change.node.row) !== 0) {
       this.push({
         type: "remove",
@@ -10973,11 +10675,11 @@ function unwrap(c) {
 }
 
 // ../zql/src/query/query-impl.ts
-function newQuery(delegate, tableSchema) {
-  return new QueryImpl(delegate, normalizeTableSchema(tableSchema));
+function newQuery(delegate, schema, table2) {
+  return new QueryImpl(delegate, schema, table2);
 }
-function newQueryWithDetails(delegate, schema, ast, format) {
-  return new QueryImpl(delegate, schema, ast, format);
+function newQueryWithDetails(delegate, schema, tableName, ast, format) {
+  return new QueryImpl(delegate, schema, tableName, ast, format);
 }
 function staticParam(anchorClass, field) {
   return {
@@ -10991,12 +10693,14 @@ var SUBQ_PREFIX = "zsubq_";
 var AbstractQuery = class {
   #ast;
   #schema;
+  #tableName;
   #format;
   #hash = "";
-  constructor(schema, ast, format) {
+  constructor(schema, tableName, ast, format) {
     this.#ast = ast;
     this.#format = format ?? { singular: false, relationships: {} };
     this.#schema = schema;
+    this.#tableName = tableName;
   }
   get format() {
     return this.#format;
@@ -11012,6 +10716,7 @@ var AbstractQuery = class {
   one() {
     return this._newQuery(
       this.#schema,
+      this.#tableName,
       {
         ...this.#ast,
         limit: 1
@@ -11022,31 +10727,49 @@ var AbstractQuery = class {
       }
     );
   }
-  whereExists(relationship, cb = (q) => q) {
+  whereExists(relationship, cb) {
     return this.where(({ exists }) => exists(relationship, cb));
   }
-  related(relationship, cb = (q) => q) {
+  related(relationship, cb) {
     if (relationship.startsWith(SUBQ_PREFIX)) {
       throw new Error(
         `Relationship names may not start with "${SUBQ_PREFIX}". That is a reserved prefix.`
       );
     }
-    const related = this.#schema.relationships[relationship];
+    cb = cb ?? ((q) => q);
+    const related = this.#schema.relationships[this.#tableName][relationship];
     assert(related, "Invalid relationship");
-    if (isFieldRelationship(related)) {
-      const { destSchema } = related;
+    if (isOneHop(related)) {
+      const { destSchema, destField, sourceField, cardinality } = related[0];
       const sq = cb(
         this._newQuery(
+          this.#schema,
           destSchema,
           {
-            table: destSchema.tableName,
+            table: destSchema,
             alias: relationship
           },
-          void 0
+          {
+            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: [
@@ -11054,10 +10777,13 @@ var AbstractQuery = class {
             {
               system: this._system,
               correlation: {
-                parentField: related.sourceField,
-                childField: related.destField
+                parentField: sourceField,
+                childField: destField
               },
-              subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
+              subquery: addPrimaryKeysToAst(
+                this.#schema.tables[destSchema],
+                sq.#ast
+              )
             }
           ]
         },
@@ -11070,23 +10796,32 @@ var AbstractQuery = class {
         }
       );
     }
-    if (isJunctionRelationship(related)) {
+    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.tableName,
+            table: destSchema,
             alias: relationship
           },
-          void 0
+          {
+            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: [
@@ -11098,9 +10833,12 @@ var AbstractQuery = class {
                 childField: firstRelation.destField
               },
               subquery: {
-                table: junctionSchema.tableName,
+                table: junctionSchema,
                 alias: relationship,
-                orderBy: addPrimaryKeys(junctionSchema, void 0),
+                orderBy: addPrimaryKeys(
+                  this.#schema.tables[junctionSchema],
+                  void 0
+                ),
                 related: [
                   {
                     system: this._system,
@@ -11109,7 +10847,10 @@ var AbstractQuery = class {
                       childField: secondRelation.destField
                     },
                     hidden: true,
-                    subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
+                    subquery: addPrimaryKeysToAst(
+                      this.#schema.tables[destSchema],
+                      sq.#ast
+                    )
                   }
                 ]
               }
@@ -11141,6 +10882,7 @@ var AbstractQuery = class {
     }
     return this._newQuery(
       this.#schema,
+      this.#tableName,
       {
         ...this.#ast,
         where: dnf(cond)
@@ -11151,6 +10893,7 @@ var AbstractQuery = class {
   start(row, opts) {
     return this._newQuery(
       this.#schema,
+      this.#tableName,
       {
         ...this.#ast,
         start: {
@@ -11170,6 +10913,7 @@ var AbstractQuery = class {
     }
     return this._newQuery(
       this.#schema,
+      this.#tableName,
       {
         ...this.#ast,
         limit
@@ -11180,6 +10924,7 @@ var AbstractQuery = class {
   orderBy(field, direction) {
     return this._newQuery(
       this.#schema,
+      this.#tableName,
       {
         ...this.#ast,
         orderBy: [...this.#ast.orderBy ?? [], [field, direction]]
@@ -11188,15 +10933,18 @@ var AbstractQuery = class {
     );
   }
   _exists = (relationship, cb = (q) => q) => {
-    const related = this.#schema.relationships[relationship];
+    const related = this.#schema.relationships[this.#tableName][relationship];
     assert(related, "Invalid relationship");
-    if (isFieldRelationship(related)) {
-      const { destSchema } = related;
+    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.tableName,
+            table: destSchema,
             alias: `${SUBQ_PREFIX}${relationship}`
           },
           void 0
@@ -11207,24 +10955,32 @@ var AbstractQuery = class {
         related: {
           system: this._system,
           correlation: {
-            parentField: related.sourceField,
-            childField: related.destField
+            parentField: sourceField,
+            childField: destField
           },
-          subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
+          subquery: addPrimaryKeysToAst(
+            this.#schema.tables[destSchema],
+            sq.#ast
+          )
         },
         op: "EXISTS"
       };
     }
-    if (isJunctionRelationship(related)) {
+    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.tableName,
+            table: destSchema,
             alias: `${SUBQ_PREFIX}${relationship}`
           },
           void 0
@@ -11239,9 +10995,12 @@ var AbstractQuery = class {
             childField: firstRelation.destField
           },
           subquery: {
-            table: junctionSchema.tableName,
+            table: junctionSchema,
             alias: `${SUBQ_PREFIX}${relationship}`,
-            orderBy: addPrimaryKeys(junctionSchema, void 0),
+            orderBy: addPrimaryKeys(
+              this.#schema.tables[junctionSchema],
+              void 0
+            ),
             where: {
               type: "correlatedSubquery",
               related: {
@@ -11250,7 +11009,10 @@ var AbstractQuery = class {
                   parentField: secondRelation.sourceField,
                   childField: secondRelation.destField
                 },
-                subquery: addPrimaryKeysToAst(destSchema, queryToDest.#ast)
+                subquery: addPrimaryKeysToAst(
+                  this.#schema.tables[destSchema],
+                  queryToDest.#ast
+                )
               },
               op: "EXISTS"
             }
@@ -11264,7 +11026,10 @@ var AbstractQuery = class {
   #completedAST;
   _completeAst() {
     if (!this.#completedAST) {
-      const finalOrderBy = addPrimaryKeys(this.#schema, this.#ast.orderBy);
+      const finalOrderBy = addPrimaryKeys(
+        this.#schema.tables[this.#tableName],
+        this.#ast.orderBy
+      );
       if (this.#ast.start) {
         const { row } = this.#ast.start;
         const narrowedRow = {};
@@ -11282,7 +11047,10 @@ var AbstractQuery = class {
       } else {
         this.#completedAST = {
           ...this.#ast,
-          orderBy: addPrimaryKeys(this.#schema, this.#ast.orderBy)
+          orderBy: addPrimaryKeys(
+            this.#schema.tables[this.#tableName],
+            this.#ast.orderBy
+          )
         };
       }
     }
@@ -11294,8 +11062,8 @@ var completedAstSymbol = Symbol();
 var QueryImpl = class extends AbstractQuery {
   #delegate;
   #ast;
-  constructor(delegate, schema, ast = { table: schema.tableName }, format) {
-    super(schema, ast, format);
+  constructor(delegate, schema, tableName, ast = { table: tableName }, format) {
+    super(schema, tableName, ast, format);
     this.#delegate = delegate;
     this.#ast = ast;
   }
@@ -11307,8 +11075,8 @@ var QueryImpl = class extends AbstractQuery {
   get [completedAstSymbol]() {
     return this._completeAst();
   }
-  _newQuery(schema, ast, format) {
-    return newQueryWithDetails(this.#delegate, schema, ast, format);
+  _newQuery(schema, tableName, ast, format) {
+    return newQueryWithDetails(this.#delegate, schema, tableName, ast, format);
   }
   materialize(factory) {
     const ast = this._completeAst();
@@ -11390,18 +11158,21 @@ function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit,
   });
   return v2;
 }
+function isCompoundKey(field) {
+  return Array.isArray(field) && field.length >= 1;
+}
 
 // ../zql/src/query/auth-query.ts
 var AuthQuery = class _AuthQuery extends AbstractQuery {
-  constructor(schema, ast = { table: schema.tableName }, format) {
-    super(schema, ast, format);
+  constructor(schema, tableName, ast = { table: tableName }, format) {
+    super(schema, tableName, ast, format);
   }
   expressionBuilder() {
     return new ExpressionBuilder(this._exists);
   }
   _system = "permissions";
-  _newQuery(schema, ast, format) {
-    return new _AuthQuery(schema, ast, format);
+  _newQuery(schema, tableName, ast, format) {
+    return new _AuthQuery(schema, tableName, ast, format);
   }
   get ast() {
     return this._completeAst();
@@ -11421,10 +11192,9 @@ var AuthQuery = class _AuthQuery extends AbstractQuery {
 var ANYONE_CAN = void 0;
 var NOBODY_CAN = [];
 async function definePermissions(schema, definer) {
-  const normalizedSchema = normalizeSchema(schema);
   const expressionBuilders = {};
-  for (const [name, tableSchema] of Object.entries(normalizedSchema.tables)) {
-    expressionBuilders[name] = new AuthQuery(tableSchema).expressionBuilder();
+  for (const name of Object.keys(schema.tables)) {
+    expressionBuilders[name] = new AuthQuery(schema, name).expressionBuilder();
   }
   const config = await definer();
   return compilePermissions(config, expressionBuilders);
@@ -11528,10 +11298,160 @@ function baseTracker(anchor) {
 var authDataRef = baseTracker("authData");
 var preMutationRowRef = baseTracker("preMutationRow");
 
-// ../zero-schema/src/schema.ts
-function createSchema(schema) {
-  normalizeSchema(schema);
-  return schema;
+// ../zero-schema/src/builder/table-builder.ts
+function table(name) {
+  return new TableBuilder({
+    name,
+    columns: {},
+    primaryKey: []
+  });
+}
+function string8() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+function number5() {
+  return new ColumnBuilder({
+    type: "number",
+    optional: false,
+    customType: null
+  });
+}
+function boolean4() {
+  return new ColumnBuilder({
+    type: "boolean",
+    optional: false,
+    customType: null
+  });
+}
+function json() {
+  return new ColumnBuilder({
+    type: "json",
+    optional: false,
+    customType: null
+  });
+}
+function enumeration() {
+  return new ColumnBuilder({
+    type: "string",
+    optional: false,
+    customType: null
+  });
+}
+var TableBuilder = class {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  columns(columns) {
+    const columnSchemas = Object.fromEntries(
+      Object.entries(columns).map(([k, v2]) => [k, v2.schema])
+    );
+    return new TableBuilderWithColumns({
+      ...this.#schema,
+      columns: columnSchemas
+    });
+  }
+};
+var TableBuilderWithColumns = class _TableBuilderWithColumns {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  primaryKey(...pkColumnNames) {
+    return new _TableBuilderWithColumns({
+      ...this.#schema,
+      primaryKey: pkColumnNames
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+  build() {
+    if (this.#schema.primaryKey.length === 0) {
+      throw new Error(`Table "${this.#schema.name}" is missing a primary key`);
+    }
+    return this.#schema;
+  }
+};
+var ColumnBuilder = class _ColumnBuilder {
+  #schema;
+  constructor(schema) {
+    this.#schema = schema;
+  }
+  optional() {
+    return new _ColumnBuilder({
+      ...this.#schema,
+      optional: true
+    });
+  }
+  get schema() {
+    return this.#schema;
+  }
+};
+
+// ../zero-schema/src/builder/schema-builder.ts
+function createSchema(version3, tables, relationships2) {
+  const retTables = {};
+  const retRelationships = {};
+  Object.values(tables).forEach((table2) => {
+    retTables[table2.schema.name] = table2.build();
+  });
+  Object.values(relationships2 ?? {}).forEach((relationship) => {
+    retRelationships[relationship.name] = relationship.relationships;
+    checkRelationship(relationship.relationships, relationship.name, retTables);
+  });
+  return {
+    version: version3,
+    tables: retTables,
+    relationships: retRelationships
+  };
+}
+function checkRelationship(relationships2, tableName, tables) {
+  Object.entries(relationships2).forEach(([name, rel]) => {
+    let source = tables[tableName];
+    rel.forEach((connection) => {
+      if (!tables[connection.destSchema]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", destination table "${connection.destSchema}" is missing in the schema`
+        );
+      }
+      if (!source.columns[connection.sourceField[0]]) {
+        throw new Error(
+          `For relationship "${tableName}"."${name}", the source field "${connection.sourceField[0]}" is missing in the table schema "${source.name}"`
+        );
+      }
+      source = tables[connection.destSchema];
+    });
+  });
+}
+
+// ../zero-schema/src/builder/relationship-builder.ts
+function relationships(table2, cb) {
+  const relationships2 = cb({ many, one });
+  return {
+    name: table2.schema.name,
+    relationships: relationships2
+  };
+}
+function many(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "many"
+  }));
+}
+function one(...args) {
+  return args.map((arg) => ({
+    sourceField: arg.sourceField,
+    destField: arg.destField,
+    destSchema: arg.destSchema.schema.name,
+    cardinality: "one"
+  }));
 }
 
 // ../zql/src/query/escape-like.ts
@@ -11927,145 +11847,36 @@ var Disconnected = 0;
 var Connecting = 1;
 var Connected = 2;
 
-// ../btree/b+tree.ts
-function defaultComparator(a, b) {
-  if (Number.isFinite(a) && Number.isFinite(b)) {
-    return a - b;
-  }
-  let ta = typeof a;
-  let tb = typeof b;
-  if (ta !== tb) {
-    return ta < tb ? -1 : 1;
-  }
-  if (ta === "object") {
-    if (a === null)
-      return b === null ? 0 : -1;
-    else if (b === null)
-      return 1;
-    a = a.valueOf();
-    b = b.valueOf();
-    ta = typeof a;
-    tb = typeof b;
-    if (ta !== tb) {
-      return ta < tb ? -1 : 1;
+// ../shared/src/btree-set.ts
+var MAX_NODE_SIZE = 32;
+var BTreeSet = class {
+  #root = emptyLeaf;
+  size = 0;
+  comparator;
+  constructor(comparator2, entries) {
+    this.comparator = comparator2;
+    if (entries) {
+      for (const key of entries) {
+        this.add(key);
+      }
     }
   }
-  if (a < b)
-    return -1;
-  if (a > b)
-    return 1;
-  if (a === b)
-    return 0;
-  if (Number.isNaN(a))
-    return Number.isNaN(b) ? 0 : -1;
-  else if (Number.isNaN(b))
-    return 1;
-  return Array.isArray(a) ? 0 : Number.NaN;
-}
-var BTree = class _BTree {
-  _root = EmptyLeaf;
-  _size = 0;
-  _maxNodeSize;
-  /**
-   * provides a total order over keys (and a strict partial order over the type K)
-   * @returns a negative value if a < b, 0 if a === b and a positive value if a > b
-   */
-  _compare;
-  /**
-   * Initializes an empty B+ tree.
-   * @param compare Custom function to compare pairs of elements in the tree.
-   *   If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
-   * @param entries A set of key-value pairs to initialize the tree
-   * @param maxNodeSize Branching factor (maximum items or children per node)
-   *   Must be in range 4..256. If undefined or <4 then default is used; if >256 then 256.
-   */
-  constructor(entries, compare, maxNodeSize) {
-    this._maxNodeSize = maxNodeSize >= 4 ? Math.min(maxNodeSize, 256) : 32;
-    this._compare = compare || defaultComparator;
-    if (entries)
-      this.setPairs(entries);
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // ES6 Map<K,V> methods /////////////////////////////////////////////////////
-  /** Gets the number of key-value pairs in the tree. */
-  get size() {
-    return this._size;
-  }
-  /** Gets the number of key-value pairs in the tree. */
-  get length() {
-    return this._size;
-  }
-  /** Returns true iff the tree contains no key-value pairs. */
-  get isEmpty() {
-    return this._size === 0;
-  }
   /** Releases the tree so that its size is 0. */
   clear() {
-    this._root = EmptyLeaf;
-    this._size = 0;
-  }
-  /** Runs a function for each key-value pair, in order from smallest to
-   *  largest key. For compatibility with ES6 Map, the argument order to
-   *  the callback is backwards: value first, then key. Call forEachPair
-   *  instead to receive the key as the first argument.
-   * @param thisArg If provided, this parameter is assigned as the `this`
-   *        value for each callback.
-   * @returns the number of values that were sent to the callback,
-   *        or the R value if the callback returned {break:R}. */
-  forEach(callback, thisArg) {
-    if (thisArg !== void 0)
-      callback = callback.bind(thisArg);
-    return this.forEachPair((k, v2) => callback(v2, k, this));
-  }
-  /** Runs a function for each key-value pair, in order from smallest to
-   *  largest key. The callback can return {break:R} (where R is any value
-   *  except undefined) to stop immediately and return R from forEachPair.
-   * @param onFound A function that is called for each key-value pair. This
-   *        function can return {break:R} to stop early with result R.
-   *        The reason that you must return {break:R} instead of simply R
-   *        itself is for consistency with editRange(), which allows
-   *        multiple actions, not just breaking.
-   * @param initialCounter This is the value of the third argument of
-   *        `onFound` the first time it is called. The counter increases
-   *        by one each time `onFound` is called. Default value: 0
-   * @returns the number of pairs sent to the callback (plus initialCounter,
-   *        if you provided one). If the callback returned {break:R} then
-   *        the R value is returned instead. */
-  forEachPair(callback, initialCounter) {
-    var low = this.minKey(), high = this.maxKey();
-    return this.forRange(low, high, true, callback, initialCounter);
+    this.#root = emptyLeaf;
+    this.size = 0;
   }
-  /**
-   * Finds a pair in the tree and returns the associated value.
-   * @param defaultValue a value to return if the key was not found.
-   * @returns the value, or defaultValue if the key was not found.
-   * @description Computational complexity: O(log size)
-   */
-  get(key, defaultValue) {
-    return this._root.get(key, defaultValue, this);
+  get(key) {
+    return this.#root.get(key, this);
   }
-  /**
-   * Adds or overwrites a key-value pair in the B+ tree.
-   * @param key the key is used to determine the sort order of
-   *        data in the tree.
-   * @param value data to associate with the key (optional)
-   * @param overwrite Whether to overwrite an existing key-value pair
-   *        (default: true). If this is false and there is an existing
-   *        key-value pair then this method has no effect.
-   * @returns true if a new key-value pair was added.
-   * @description Computational complexity: O(log size)
-   * Note: when overwriting a previous entry, the key is updated
-   * as well as the value. This has no effect unless the new key
-   * has data that does not affect its sort order.
-   */
-  set(key, value, overwrite) {
-    if (this._root.isShared)
-      this._root = this._root.clone();
-    var result = this._root.set(key, value, overwrite, this);
-    if (result === true || result === false)
-      return result;
-    this._root = new BNodeInternal([this._root, result]);
-    return true;
+  add(key) {
+    if (this.#root.isShared)
+      this.#root = this.#root.clone();
+    const result = this.#root.set(key, this);
+    if (result === null)
+      return this;
+    this.#root = new BNodeInternal([this.#root, result]);
+    return this;
   }
   /**
    * Returns true if the key exists in the B+ tree, false if not.
@@ -12075,7 +11886,7 @@ var BTree = class _BTree {
    * @description Computational complexity: O(log size)
    */
   has(key) {
-    return this.forRange(key, key, true, void 0) !== 0;
+    return this.#root.has(key, this);
   }
   /**
    * Removes a single key-value pair from the B+ tree.
@@ -12084,1111 +11895,240 @@ var BTree = class _BTree {
    * @description Computational complexity: O(log size)
    */
   delete(key) {
-    return this.editRange(key, key, true, DeleteRange) !== 0;
-  }
-  with(key, value, overwrite) {
-    let nu = this.clone();
-    return nu.set(key, value, overwrite) || overwrite ? nu : this;
-  }
-  /** Returns a copy of the tree with the specified key-value pairs set. */
-  withPairs(pairs, overwrite) {
-    let nu = this.clone();
-    return nu.setPairs(pairs, overwrite) !== 0 || overwrite ? nu : this;
-  }
-  /** Returns a copy of the tree with the specified keys present.
-   *  @param keys The keys to add. If a key is already present in the tree,
-   *         neither the existing key nor the existing value is modified.
-   *  @param returnThisIfUnchanged if true, returns this if all keys already
-   *  existed. Performance note: due to the architecture of this class, all
-   *  node(s) leading to existing keys are cloned even if the collection is
-   *  ultimately unchanged.
-   */
-  withKeys(keys, returnThisIfUnchanged) {
-    let nu = this.clone(), changed = false;
-    for (var i = 0; i < keys.length; i++)
-      changed = nu.set(keys[i], void 0, false) || changed;
-    return returnThisIfUnchanged && !changed ? this : nu;
-  }
-  /** Returns a copy of the tree with the specified key removed.
-   * @param returnThisIfUnchanged if true, returns this if the key didn't exist.
-   *  Performance note: due to the architecture of this class, node(s) leading
-   *  to where the key would have been stored are cloned even when the key
-   *  turns out not to exist and the collection is unchanged.
-   */
-  without(key, returnThisIfUnchanged) {
-    return this.withoutRange(key, key, true, returnThisIfUnchanged);
-  }
-  /** Returns a copy of the tree with the specified keys removed.
-   * @param returnThisIfUnchanged if true, returns this if none of the keys
-   *  existed. Performance note: due to the architecture of this class,
-   *  node(s) leading to where the key would have been stored are cloned
-   *  even when the key turns out not to exist.
-   */
-  withoutKeys(keys, returnThisIfUnchanged) {
-    let nu = this.clone();
-    return nu.deleteKeys(keys) || !returnThisIfUnchanged ? nu : this;
-  }
-  /** Returns a copy of the tree with the specified range of keys removed. */
-  withoutRange(low, high, includeHigh, returnThisIfUnchanged) {
-    let nu = this.clone();
-    if (nu.deleteRange(low, high, includeHigh) === 0 && returnThisIfUnchanged)
-      return this;
-    return nu;
-  }
-  /** Returns a copy of the tree with pairs removed whenever the callback
-   *  function returns false. `where()` is a synonym for this method. */
-  filter(callback, returnThisIfUnchanged) {
-    var nu = this.greedyClone();
-    var del;
-    nu.editAll((k, v2, i) => {
-      if (!callback(k, v2, i))
-        return del = Delete;
-      return void 0;
-    });
-    if (!del && returnThisIfUnchanged)
-      return this;
-    return nu;
-  }
-  /** Returns a copy of the tree with all values altered by a callback function. */
-  mapValues(callback) {
-    var tmp = {};
-    var nu = this.greedyClone();
-    nu.editAll((k, v2, i) => {
-      return tmp.value = callback(v2, k, i), tmp;
-    });
-    return nu;
+    return this.#delete(key);
   }
-  reduce(callback, initialValue) {
-    let i = 0, p = initialValue;
-    var it = this.entries(this.minKey(), ReusedArray), next;
-    while (!(next = it.next()).done)
-      p = callback(p, next.value, i++, this);
-    return p;
+  #delete(key) {
+    let root = this.#root;
+    if (root.isShared) {
+      this.#root = root = root.clone();
+    }
+    try {
+      return root.delete(key, this);
+    } finally {
+      let isShared;
+      while (root.keys.length <= 1 && root.isInternal()) {
+        isShared ||= root.isShared;
+        this.#root = root = root.keys.length === 0 ? emptyLeaf : root.children[0];
+      }
+      if (isShared) {
+        root.isShared = true;
+      }
+    }
   }
-  /////////////////////////////////////////////////////////////////////////////
-  // Iterator methods /////////////////////////////////////////////////////////
-  /** Returns an iterator that provides items in order (ascending order if
-   *  the collection's comparator uses ascending order, as is the default.)
-   *  @param lowestKey First key to be iterated, or undefined to start at
-   *         minKey(). If the specified key doesn't exist then iteration
-   *         starts at the next higher key (according to the comparator).
-   *  @param reusedArray Optional array used repeatedly to store key-value
-   *         pairs, to avoid creating a new array on every iteration.
-   */
-  entries(lowestKey, reusedArray) {
-    var info = this.findPath(lowestKey);
-    if (info === void 0)
-      return iterator();
-    var { nodequeue, nodeindex, leaf } = info;
-    var state = reusedArray !== void 0 ? 1 : 0;
-    var i = lowestKey === void 0 ? -1 : leaf.indexOf(lowestKey, 0, this._compare) - 1;
-    return iterator(() => {
-      jump:
-        for (; ; ) {
-          switch (state) {
-            case 0:
-              if (++i < leaf.keys.length)
-                return { done: false, value: [leaf.keys[i], leaf.values[i]] };
-              state = 2;
-              continue;
-            case 1:
-              if (++i < leaf.keys.length) {
-                reusedArray[0] = leaf.keys[i], reusedArray[1] = leaf.values[i];
-                return { done: false, value: reusedArray };
-              }
-              state = 2;
-            case 2:
-              for (var level = -1; ; ) {
-                if (++level >= nodequeue.length) {
-                  state = 3;
-                  continue jump;
-                }
-                if (++nodeindex[level] < nodequeue[level].length)
-                  break;
-              }
-              for (; level > 0; level--) {
-                nodequeue[level - 1] = nodequeue[level][nodeindex[level]].children;
-                nodeindex[level - 1] = 0;
-              }
-              leaf = nodequeue[0][nodeindex[0]];
-              i = -1;
-              state = reusedArray !== void 0 ? 1 : 0;
-              continue;
-            case 3:
-              return { done: true, value: void 0 };
-          }
-        }
-    });
+  keys() {
+    return valuesFrom(this.#root, this.comparator, void 0, true);
   }
-  /** Returns an iterator that provides items in reversed order.
-   *  @param highestKey Key at which to start iterating, or undefined to
-   *         start at maxKey(). If the specified key doesn't exist then iteration
-   *         starts at the next lower key (according to the comparator).
-   *  @param reusedArray Optional array used repeatedly to store key-value
-   *         pairs, to avoid creating a new array on every iteration.
-   *  @param skipHighest Iff this flag is true and the highestKey exists in the
-   *         collection, the pair matching highestKey is skipped, not iterated.
-   */
-  entriesReversed(highestKey, reusedArray, skipHighest) {
-    if (highestKey === void 0) {
-      highestKey = this.maxKey();
-      skipHighest = void 0;
-      if (highestKey === void 0)
-        return iterator();
-    }
-    var { nodequeue, nodeindex, leaf } = this.findPath(highestKey) || this.findPath(this.maxKey());
-    check(!nodequeue[0] || leaf === nodequeue[0][nodeindex[0]], "wat!");
-    var i = leaf.indexOf(highestKey, 0, this._compare);
-    if (!skipHighest && i < leaf.keys.length && this._compare(leaf.keys[i], highestKey) <= 0)
-      i++;
-    var state = reusedArray !== void 0 ? 1 : 0;
-    return iterator(() => {
-      jump:
-        for (; ; ) {
-          switch (state) {
-            case 0:
-              if (--i >= 0)
-                return { done: false, value: [leaf.keys[i], leaf.values[i]] };
-              state = 2;
-              continue;
-            case 1:
-              if (--i >= 0) {
-                reusedArray[0] = leaf.keys[i], reusedArray[1] = leaf.values[i];
-                return { done: false, value: reusedArray };
-              }
-              state = 2;
-            case 2:
-              for (var level = -1; ; ) {
-                if (++level >= nodequeue.length) {
-                  state = 3;
-                  continue jump;
-                }
-                if (--nodeindex[level] >= 0)
-                  break;
-              }
-              for (; level > 0; level--) {
-                nodequeue[level - 1] = nodequeue[level][nodeindex[level]].children;
-                nodeindex[level - 1] = nodequeue[level - 1].length - 1;
-              }
-              leaf = nodequeue[0][nodeindex[0]];
-              i = leaf.keys.length;
-              state = reusedArray !== void 0 ? 1 : 0;
-              continue;
-            case 3:
-              return { done: true, value: void 0 };
-          }
-        }
-    });
+  values() {
+    return valuesFrom(this.#root, this.comparator, void 0, true);
   }
-  /* Used by entries() and entriesReversed() to prepare to start iterating.
-   * It develops a "node queue" for each non-leaf level of the tree.
-   * Levels are numbered "bottom-up" so that level 0 is a list of leaf
-   * nodes from a low-level non-leaf node. The queue at a given level L
-   * consists of nodequeue[L] which is the children of a BNodeInternal,
-   * and nodeindex[L], the current index within that child list, such
-   * such that nodequeue[L-1] === nodequeue[L][nodeindex[L]].children.
-   * (However inside this function the order is reversed.)
-   */
-  findPath(key) {
-    var nextnode = this._root;
-    var nodequeue, nodeindex;
-    if (nextnode.isLeaf) {
-      nodequeue = EmptyArray, nodeindex = EmptyArray;
-    } else {
-      nodequeue = [], nodeindex = [];
-      for (var d = 0; !nextnode.isLeaf; d++) {
-        nodequeue[d] = nextnode.children;
-        nodeindex[d] = key === void 0 ? 0 : nextnode.indexOf(key, 0, this._compare);
-        if (nodeindex[d] >= nodequeue[d].length)
-          return;
-        nextnode = nodequeue[d][nodeindex[d]];
-      }
-      nodequeue.reverse();
-      nodeindex.reverse();
-    }
-    return { nodequeue, nodeindex, leaf: nextnode };
+  valuesFrom(lowestKey, inclusive = true) {
+    return valuesFrom(this.#root, this.comparator, lowestKey, inclusive);
   }
-  /**
-   * Computes the differences between `this` and `other`.
-   * For efficiency, the diff is returned via invocations of supplied handlers.
-   * The computation is optimized for the case in which the two trees have large amounts
-   * of shared data (obtained by calling the `clone` or `with` APIs) and will avoid
-   * any iteration of shared state.
-   * The handlers can cause computation to early exit by returning {break: R}.
-   * Neither of the collections should be changed during the comparison process (in your callbacks), as this method assumes they will not be mutated.
-   * @param other The tree to compute a diff against.
-   * @param onlyThis Callback invoked for all keys only present in `this`.
-   * @param onlyOther Callback invoked for all keys only present in `other`.
-   * @param different Callback invoked for all keys with differing values.
-   */
-  diffAgainst(other, onlyThis, onlyOther, different) {
-    if (other._compare !== this._compare) {
-      throw new Error("Tree comparators are not the same.");
-    }
-    if (this.isEmpty || other.isEmpty) {
-      if (this.isEmpty && other.isEmpty)
-        return void 0;
-      if (this.isEmpty)
-        return onlyOther === void 0 ? void 0 : _BTree.stepToEnd(_BTree.makeDiffCursor(other), onlyOther);
-      return onlyThis === void 0 ? void 0 : _BTree.stepToEnd(_BTree.makeDiffCursor(this), onlyThis);
-    }
-    const { _compare } = this;
-    const thisCursor = _BTree.makeDiffCursor(this);
-    const otherCursor = _BTree.makeDiffCursor(other);
-    let thisSuccess = true, otherSuccess = true, prevCursorOrder = _BTree.compare(thisCursor, otherCursor, _compare);
-    while (thisSuccess && otherSuccess) {
-      const cursorOrder = _BTree.compare(thisCursor, otherCursor, _compare);
-      const {
-        leaf: thisLeaf,
-        internalSpine: thisInternalSpine,
-        levelIndices: thisLevelIndices
-      } = thisCursor;
-      const {
-        leaf: otherLeaf,
-        internalSpine: otherInternalSpine,
-        levelIndices: otherLevelIndices
-      } = otherCursor;
-      if (thisLeaf || otherLeaf) {
-        if (prevCursorOrder !== 0) {
-          if (cursorOrder === 0) {
-            if (thisLeaf && otherLeaf && different) {
-              const valThis = thisLeaf.values[thisLevelIndices[thisLevelIndices.length - 1]];
-              const valOther = otherLeaf.values[otherLevelIndices[otherLevelIndices.length - 1]];
-              if (!Object.is(valThis, valOther)) {
-                const result = different(
-                  thisCursor.currentKey,
-                  valThis,
-                  valOther
-                );
-                if (result && result.break)
-                  return result.break;
-              }
-            }
-          } else if (cursorOrder > 0) {
-            if (otherLeaf && onlyOther) {
-              const otherVal = otherLeaf.values[otherLevelIndices[otherLevelIndices.length - 1]];
-              const result = onlyOther(otherCursor.currentKey, otherVal);
-              if (result && result.break)
-                return result.break;
-            }
-          } else if (onlyThis) {
-            if (thisLeaf && prevCursorOrder !== 0) {
-              const valThis = thisLeaf.values[thisLevelIndices[thisLevelIndices.length - 1]];
-              const result = onlyThis(thisCursor.currentKey, valThis);
-              if (result && result.break)
-                return result.break;
-            }
-          }
-        }
-      } else if (!thisLeaf && !otherLeaf && cursorOrder === 0) {
-        const lastThis = thisInternalSpine.length - 1;
-        const lastOther = otherInternalSpine.length - 1;
-        const nodeThis = thisInternalSpine[lastThis][thisLevelIndices[lastThis]];
-        const nodeOther = otherInternalSpine[lastOther][otherLevelIndices[lastOther]];
-        if (nodeOther === nodeThis) {
-          prevCursorOrder = 0;
-          thisSuccess = _BTree.step(thisCursor, true);
-          otherSuccess = _BTree.step(otherCursor, true);
-          continue;
-        }
-      }
-      prevCursorOrder = cursorOrder;
-      if (cursorOrder < 0) {
-        thisSuccess = _BTree.step(thisCursor);
-      } else {
-        otherSuccess = _BTree.step(otherCursor);
-      }
-    }
-    if (thisSuccess && onlyThis)
-      return _BTree.finishCursorWalk(
-        thisCursor,
-        otherCursor,
-        _compare,
-        onlyThis
-      );
-    if (otherSuccess && onlyOther)
-      return _BTree.finishCursorWalk(
-        otherCursor,
-        thisCursor,
-        _compare,
-        onlyOther
-      );
-    return void 0;
+  valuesReversed() {
+    return valuesFromReversed(
+      this.#maxKey(),
+      this.#root,
+      this.comparator,
+      void 0,
+      true
+    );
   }
-  ///////////////////////////////////////////////////////////////////////////
-  // Helper methods for diffAgainst /////////////////////////////////////////
-  static finishCursorWalk(cursor, cursorFinished, compareKeys, callback) {
-    const compared = _BTree.compare(cursor, cursorFinished, compareKeys);
-    if (compared === 0) {
-      if (!_BTree.step(cursor))
-        return void 0;
-    } else if (compared < 0) {
-      check(false, "cursor walk terminated early");
-    }
-    return _BTree.stepToEnd(cursor, callback);
+  valuesFromReversed(highestKey, inclusive = true) {
+    return valuesFromReversed(
+      this.#maxKey(),
+      this.#root,
+      this.comparator,
+      highestKey,
+      inclusive
+    );
   }
-  static stepToEnd(cursor, callback) {
-    let canStep = true;
-    while (canStep) {
-      const { leaf, levelIndices, currentKey } = cursor;
-      if (leaf) {
-        const value = leaf.values[levelIndices[levelIndices.length - 1]];
-        const result = callback(currentKey, value);
-        if (result && result.break)
-          return result.break;
-      }
-      canStep = _BTree.step(cursor);
-    }
-    return void 0;
+  /** Gets the highest key in the tree. Complexity: O(1) */
+  #maxKey() {
+    return this.#root.maxKey();
   }
-  static makeDiffCursor(tree) {
-    const { _root, height } = tree;
-    return {
-      height,
-      internalSpine: [[_root]],
-      levelIndices: [0],
-      leaf: void 0,
-      currentKey: _root.maxKey()
-    };
+  [Symbol.iterator]() {
+    return this.keys();
   }
-  /**
-   * Advances the cursor to the next step in the walk of its tree.
-   * Cursors are walked backwards in sort order, as this allows them to leverage maxKey() in order to be compared in O(1).
-   * @param cursor The cursor to step
-   * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
-   * @returns true if the step was completed and false if the step would have caused the cursor to move beyond the end of the tree.
-   */
-  static step(cursor, stepToNode) {
-    const { internalSpine, levelIndices, leaf } = cursor;
-    if (stepToNode === true || leaf) {
-      const levelsLength = levelIndices.length;
-      if (stepToNode === true || levelIndices[levelsLength - 1] === 0) {
-        const spineLength = internalSpine.length;
-        if (spineLength === 0)
-          return false;
-        const nodeLevelIndex = spineLength - 1;
-        let levelIndexWalkBack = nodeLevelIndex;
-        while (levelIndexWalkBack >= 0) {
-          if (levelIndices[levelIndexWalkBack] > 0) {
-            if (levelIndexWalkBack < levelsLength - 1) {
-              cursor.leaf = void 0;
-              levelIndices.pop();
-            }
-            if (levelIndexWalkBack < nodeLevelIndex)
-              cursor.internalSpine = internalSpine.slice(
-                0,
-                levelIndexWalkBack + 1
-              );
-            cursor.currentKey = internalSpine[levelIndexWalkBack][--levelIndices[levelIndexWalkBack]].maxKey();
-            return true;
-          }
-          levelIndexWalkBack--;
+};
+function valuesFrom(root, comparator2, lowestKey, inclusive) {
+  const info = findPath(lowestKey, root, comparator2);
+  if (info === void 0) {
+    return iterator(() => ({ done: true, value: void 0 }));
+  }
+  let [nodeQueue, nodeIndex, leaf] = info;
+  let i = lowestKey === void 0 ? -1 : indexOf(lowestKey, leaf.keys, 0, comparator2) - 1;
+  if (!inclusive && i < leaf.keys.length && // +1 because we did -1 above.
+  comparator2(leaf.keys[i + 1], lowestKey) === 0) {
+    i++;
+  }
+  return iterator(() => {
+    for (; ; ) {
+      if (++i < leaf.keys.length) {
+        return { done: false, value: leaf.keys[i] };
+      }
+      let level = -1;
+      for (; ; ) {
+        if (++level >= nodeQueue.length) {
+          return { done: true, value: void 0 };
+        }
+        if (++nodeIndex[level] < nodeQueue[level].length) {
+          break;
         }
-        return false;
-      } else {
-        const valueIndex = --levelIndices[levelsLength - 1];
-        cursor.currentKey = leaf.keys[valueIndex];
-        return true;
       }
-    } else {
-      const nextLevel = internalSpine.length;
-      const currentLevel = nextLevel - 1;
-      const node = internalSpine[currentLevel][levelIndices[currentLevel]];
-      if (node.isLeaf) {
-        cursor.leaf = node;
-        const valueIndex = levelIndices[nextLevel] = node.values.length - 1;
-        cursor.currentKey = node.keys[valueIndex];
-      } else {
-        const children = node.children;
-        internalSpine[nextLevel] = children;
-        const childIndex = children.length - 1;
-        levelIndices[nextLevel] = childIndex;
-        cursor.currentKey = children[childIndex].maxKey();
+      for (; level > 0; level--) {
+        nodeQueue[level - 1] = nodeQueue[level][nodeIndex[level]].children;
+        nodeIndex[level - 1] = 0;
       }
-      return true;
+      leaf = nodeQueue[0][nodeIndex[0]];
+      i = -1;
     }
+  });
+}
+function valuesFromReversed(maxKey, root, comparator2, highestKey, inclusive) {
+  if (highestKey === void 0) {
+    highestKey = maxKey;
+    if (highestKey === void 0)
+      return iterator(() => ({ done: true, value: void 0 }));
   }
-  /**
-   * Compares the two cursors. Returns a value indicating which cursor is ahead in a walk.
-   * Note that cursors are advanced in reverse sorting order.
-   */
-  static compare(cursorA, cursorB, compareKeys) {
-    const {
-      height: heightA,
-      currentKey: currentKeyA,
-      levelIndices: levelIndicesA
-    } = cursorA;
-    const {
-      height: heightB,
-      currentKey: currentKeyB,
-      levelIndices: levelIndicesB
-    } = cursorB;
-    const keyComparison = compareKeys(currentKeyB, currentKeyA);
-    if (keyComparison !== 0) {
-      return keyComparison;
-    }
-    const heightMin = heightA < heightB ? heightA : heightB;
-    const depthANormalized = levelIndicesA.length - (heightA - heightMin);
-    const depthBNormalized = levelIndicesB.length - (heightB - heightMin);
-    return depthANormalized - depthBNormalized;
-  }
-  // End of helper methods for diffAgainst //////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////////
-  /** Returns a new iterator for iterating the keys of each pair in ascending order.
-   *  @param firstKey: Minimum key to include in the output. */
-  keys(firstKey) {
-    var it = this.entries(firstKey, ReusedArray);
-    return iterator(() => {
-      var n = it.next();
-      if (n.value)
-        n.value = n.value[0];
-      return n;
-    });
-  }
-  /** Returns a new iterator for iterating the values of each pair in order by key.
-   *  @param firstKey: Minimum key whose associated value is included in the output. */
-  values(firstKey) {
-    var it = this.entries(firstKey, ReusedArray);
-    return iterator(() => {
-      var n = it.next();
-      if (n.value)
-        n.value = n.value[1];
-      return n;
-    });
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // Additional methods ///////////////////////////////////////////////////////
-  /** Returns the maximum number of children/values before nodes will split. */
-  get maxNodeSize() {
-    return this._maxNodeSize;
-  }
-  /** Gets the lowest key in the tree. Complexity: O(log size) */
-  minKey() {
-    return this._root.minKey();
-  }
-  /** Gets the highest key in the tree. Complexity: O(1) */
-  maxKey() {
-    return this._root.maxKey();
-  }
-  /** Quickly clones the tree by marking the root node as shared.
-   *  Both copies remain editable. When you modify either copy, any
-   *  nodes that are shared (or potentially shared) between the two
-   *  copies are cloned so that the changes do not affect other copies.
-   *  This is known as copy-on-write behavior, or "lazy copying". */
-  clone() {
-    this._root.isShared = true;
-    var result = new _BTree(void 0, this._compare, this._maxNodeSize);
-    result._root = this._root;
-    result._size = this._size;
-    return result;
-  }
-  /** Performs a greedy clone, immediately duplicating any nodes that are
-   *  not currently marked as shared, in order to avoid marking any
-   *  additional nodes as shared.
-   *  @param force Clone all nodes, even shared ones.
-   */
-  greedyClone(force) {
-    var result = new _BTree(void 0, this._compare, this._maxNodeSize);
-    result._root = this._root.greedyClone(force);
-    result._size = this._size;
-    return result;
+  let [nodeQueue, nodeIndex, leaf] = findPath(highestKey, root, comparator2) || findPath(maxKey, root, comparator2);
+  assert(!nodeQueue[0] || leaf === nodeQueue[0][nodeIndex[0]]);
+  let i = indexOf(highestKey, leaf.keys, 0, comparator2);
+  if (inclusive && i < leaf.keys.length && comparator2(leaf.keys[i], highestKey) <= 0) {
+    i++;
   }
-  /** Gets an array filled with the contents of the tree, sorted by key */
-  toArray(maxLength = 2147483647) {
-    let min = this.minKey(), max = this.maxKey();
-    if (min !== void 0)
-      return this.getRange(min, max, true, maxLength);
-    return [];
-  }
-  /** Gets an array of all keys, sorted */
-  keysArray() {
-    var results = [];
-    this._root.forRange(
-      this.minKey(),
-      this.maxKey(),
-      true,
-      false,
-      this,
-      0,
-      (k, _v) => {
-        results.push(k);
-      }
-    );
-    return results;
-  }
-  /** Gets an array of all values, sorted by key */
-  valuesArray() {
-    var results = [];
-    this._root.forRange(
-      this.minKey(),
-      this.maxKey(),
-      true,
-      false,
-      this,
-      0,
-      (_k, v2) => {
-        results.push(v2);
+  return iterator(() => {
+    for (; ; ) {
+      if (--i >= 0) {
+        return { done: false, value: leaf.keys[i] };
       }
-    );
-    return results;
-  }
-  /** Gets a string representing the tree's data based on toArray(). */
-  toString() {
-    return this.toArray().toString();
-  }
-  /** Stores a key-value pair only if the key doesn't already exist in the tree.
-   * @returns true if a new key was added
-   */
-  setIfNotPresent(key, value) {
-    return this.set(key, value, false);
-  }
-  /** Returns the next pair whose key is larger than the specified key (or undefined if there is none).
-   * If key === undefined, this function returns the lowest pair.
-   * @param key The key to search for.
-   * @param reusedArray Optional array used repeatedly to store key-value pairs, to
-   * avoid creating a new array on every iteration.
-   */
-  nextHigherPair(key, reusedArray) {
-    reusedArray = reusedArray || [];
-    if (key === void 0) {
-      return this._root.minPair(reusedArray);
-    }
-    return this._root.getPairOrNextHigher(
-      key,
-      this._compare,
-      false,
-      reusedArray
-    );
-  }
-  /** Returns the next key larger than the specified key, or undefined if there is none.
-   *  Also, nextHigherKey(undefined) returns the lowest key.
-   */
-  nextHigherKey(key) {
-    var p = this.nextHigherPair(key, ReusedArray);
-    return p && p[0];
-  }
-  /** Returns the next pair whose key is smaller than the specified key (or undefined if there is none).
-   *  If key === undefined, this function returns the highest pair.
-   * @param key The key to search for.
-   * @param reusedArray Optional array used repeatedly to store key-value pairs, to
-   *        avoid creating a new array each time you call this method.
-   */
-  nextLowerPair(key, reusedArray) {
-    reusedArray = reusedArray || [];
-    if (key === void 0) {
-      return this._root.maxPair(reusedArray);
-    }
-    return this._root.getPairOrNextLower(
-      key,
-      this._compare,
-      false,
-      reusedArray
-    );
-  }
-  /** Returns the next key smaller than the specified key, or undefined if there is none.
-   *  Also, nextLowerKey(undefined) returns the highest key.
-   */
-  nextLowerKey(key) {
-    var p = this.nextLowerPair(key, ReusedArray);
-    return p && p[0];
-  }
-  /** Returns the key-value pair associated with the supplied key if it exists
-   *  or the pair associated with the next lower pair otherwise. If there is no
-   *  next lower pair, undefined is returned.
-   * @param key The key to search for.
-   * @param reusedArray Optional array used repeatedly to store key-value pairs, to
-   *        avoid creating a new array each time you call this method.
-   * */
-  getPairOrNextLower(key, reusedArray) {
-    return this._root.getPairOrNextLower(
-      key,
-      this._compare,
-      true,
-      reusedArray || []
-    );
-  }
-  /** Returns the key-value pair associated with the supplied key if it exists
-   *  or the pair associated with the next lower pair otherwise. If there is no
-   *  next lower pair, undefined is returned.
-   * @param key The key to search for.
-   * @param reusedArray Optional array used repeatedly to store key-value pairs, to
-   *        avoid creating a new array each time you call this method.
-   * */
-  getPairOrNextHigher(key, reusedArray) {
-    return this._root.getPairOrNextHigher(
-      key,
-      this._compare,
-      true,
-      reusedArray || []
-    );
-  }
-  /** Edits the value associated with a key in the tree, if it already exists.
-   * @returns true if the key existed, false if not.
-   */
-  changeIfPresent(key, value) {
-    return this.editRange(key, key, true, (_k, _v) => ({ value })) !== 0;
-  }
-  /**
-   * Builds an array of pairs from the specified range of keys, sorted by key.
-   * Each returned pair is also an array: pair[0] is the key, pair[1] is the value.
-   * @param low The first key in the array will be greater than or equal to `low`.
-   * @param high This method returns when a key larger than this is reached.
-   * @param includeHigh If the `high` key is present, its pair will be included
-   *        in the output if and only if this parameter is true. Note: if the
-   *        `low` key is present, it is always included in the output.
-   * @param maxLength Length limit. getRange will stop scanning the tree when
-   *                  the array reaches this size.
-   * @description Computational complexity: O(result.length + log size)
-   */
-  getRange(low, high, includeHigh, maxLength = 67108863) {
-    var results = [];
-    this._root.forRange(low, high, includeHigh, false, this, 0, (k, v2) => {
-      results.push([k, v2]);
-      return results.length > maxLength ? Break : void 0;
-    });
-    return results;
-  }
-  /** Adds all pairs from a list of key-value pairs.
-   * @param pairs Pairs to add to this tree. If there are duplicate keys,
-   *        later pairs currently overwrite earlier ones (e.g. [[0,1],[0,7]]
-   *        associates 0 with 7.)
-   * @param overwrite Whether to overwrite pairs that already exist (if false,
-   *        pairs[i] is ignored when the key pairs[i][0] already exists.)
-   * @returns The number of pairs added to the collection.
-   * @description Computational complexity: O(pairs.length * log(size + pairs.length))
-   */
-  setPairs(pairs, overwrite) {
-    var added = 0;
-    for (var i = 0; i < pairs.length; i++)
-      if (this.set(pairs[i][0], pairs[i][1], overwrite))
-        added++;
-    return added;
-  }
-  /**
-   * Scans the specified range of keys, in ascending order by key.
-   * Note: the callback `onFound` must not insert or remove items in the
-   * collection. Doing so may cause incorrect data to be sent to the
-   * callback afterward.
-   * @param low The first key scanned will be greater than or equal to `low`.
-   * @param high Scanning stops when a key larger than this is reached.
-   * @param includeHigh If the `high` key is present, `onFound` is called for
-   *        that final pair if and only if this parameter is true.
-   * @param onFound A function that is called for each key-value pair. This
-   *        function can return {break:R} to stop early with result R.
-   * @param initialCounter Initial third argument of onFound. This value
-   *        increases by one each time `onFound` is called. Default: 0
-   * @returns The number of values found, or R if the callback returned
-   *        `{break:R}` to stop early.
-   * @description Computational complexity: O(number of items scanned + log size)
-   */
-  forRange(low, high, includeHigh, onFound, initialCounter) {
-    var r = this._root.forRange(
-      low,
-      high,
-      includeHigh,
-      false,
-      this,
-      initialCounter || 0,
-      onFound
-    );
-    return typeof r === "number" ? r : r.break;
-  }
-  /**
-   * Scans and potentially modifies values for a subsequence of keys.
-   * Note: the callback `onFound` should ideally be a pure function.
-   *   Specfically, it must not insert items, call clone(), or change
-   *   the collection except via return value; out-of-band editing may
-   *   cause an exception or may cause incorrect data to be sent to
-   *   the callback (duplicate or missed items). It must not cause a
-   *   clone() of the collection, otherwise the clone could be modified
-   *   by changes requested by the callback.
-   * @param low The first key scanned will be greater than or equal to `low`.
-   * @param high Scanning stops when a key larger than this is reached.
-   * @param includeHigh If the `high` key is present, `onFound` is called for
-   *        that final pair if and only if this parameter is true.
-   * @param onFound A function that is called for each key-value pair. This
-   *        function can return `{value:v}` to change the value associated
-   *        with the current key, `{delete:true}` to delete the current pair,
-   *        `{break:R}` to stop early with result R, or it can return nothing
-   *        (undefined or {}) to cause no effect and continue iterating.
-   *        `{break:R}` can be combined with one of the other two commands.
-   *        The third argument `counter` is the number of items iterated
-   *        previously; it equals 0 when `onFound` is called the first time.
-   * @returns The number of values scanned, or R if the callback returned
-   *        `{break:R}` to stop early.
-   * @description
-   *   Computational complexity: O(number of items scanned + log size)
-   *   Note: if the tree has been cloned with clone(), any shared
-   *   nodes are copied before `onFound` is called. This takes O(n) time
-   *   where n is proportional to the amount of shared data scanned.
-   */
-  editRange(low, high, includeHigh, onFound, initialCounter) {
-    var root = this._root;
-    if (root.isShared)
-      this._root = root = root.clone();
-    try {
-      var r = root.forRange(
-        low,
-        high,
-        includeHigh,
-        true,
-        this,
-        initialCounter || 0,
-        onFound
-      );
-      return typeof r === "number" ? r : r.break;
-    } finally {
-      let isShared;
-      while (root.keys.length <= 1 && !root.isLeaf) {
-        isShared ||= root.isShared;
-        this._root = root = root.keys.length === 0 ? EmptyLeaf : root.children[0];
+      let level;
+      for (level = -1; ; ) {
+        if (++level >= nodeQueue.length) {
+          return { done: true, value: void 0 };
+        }
+        if (--nodeIndex[level] >= 0) {
+          break;
+        }
       }
-      if (isShared) {
-        root.isShared = true;
+      for (; level > 0; level--) {
+        nodeQueue[level - 1] = nodeQueue[level][nodeIndex[level]].children;
+        nodeIndex[level - 1] = nodeQueue[level - 1].length - 1;
       }
+      leaf = nodeQueue[0][nodeIndex[0]];
+      i = leaf.keys.length;
     }
+  });
+}
+function findPath(key, root, comparator2) {
+  let nextNode = root;
+  const nodeQueue = [];
+  const nodeIndex = [];
+  if (nextNode.isInternal()) {
+    for (let d = 0; nextNode.isInternal(); d++) {
+      nodeQueue[d] = nextNode.children;
+      nodeIndex[d] = key === void 0 ? 0 : indexOf(key, nextNode.keys, 0, comparator2);
+      if (nodeIndex[d] >= nodeQueue[d].length)
+        return;
+      nextNode = nodeQueue[d][nodeIndex[d]];
+    }
+    nodeQueue.reverse();
+    nodeIndex.reverse();
   }
-  /** Same as `editRange` except that the callback is called for all pairs. */
-  editAll(onFound, initialCounter) {
-    return this.editRange(
-      this.minKey(),
-      this.maxKey(),
-      true,
-      onFound,
-      initialCounter
-    );
-  }
-  /**
-   * Removes a range of key-value pairs from the B+ tree.
-   * @param low The first key scanned will be greater than or equal to `low`.
-   * @param high Scanning stops when a key larger than this is reached.
-   * @param includeHigh Specifies whether the `high` key, if present, is deleted.
-   * @returns The number of key-value pairs that were deleted.
-   * @description Computational complexity: O(log size + number of items deleted)
-   */
-  deleteRange(low, high, includeHigh) {
-    return this.editRange(low, high, includeHigh, DeleteRange);
-  }
-  /** Deletes a series of keys from the collection. */
-  deleteKeys(keys) {
-    for (var i = 0, r = 0; i < keys.length; i++)
-      if (this.delete(keys[i]))
-        r++;
-    return r;
-  }
-  /** Gets the height of the tree: the number of internal nodes between the
-   *  BTree object and its leaf nodes (zero if there are no internal nodes). */
-  get height() {
-    let node = this._root;
-    let height = -1;
-    while (node) {
-      height++;
-      node = node.isLeaf ? void 0 : node.children[0];
-    }
-    return height;
-  }
-  /** Makes the object read-only to ensure it is not accidentally modified.
-   *  Freezing does not have to be permanent; unfreeze() reverses the effect.
-   *  This is accomplished by replacing mutator functions with a function
-   *  that throws an Error. Compared to using a property (e.g. this.isFrozen)
-   *  this implementation gives better performance in non-frozen BTrees.
-   */
-  freeze() {
-    var t2 = this;
-    t2.clear = t2.set = t2.editRange = function() {
-      throw new Error("Attempted to modify a frozen BTree");
-    };
-  }
-  /** Ensures mutations are allowed, reversing the effect of freeze(). */
-  unfreeze() {
-    delete this.clear;
-    delete this.set;
-    delete this.editRange;
-  }
-  /** Returns true if the tree appears to be frozen. */
-  get isFrozen() {
-    return this.hasOwnProperty("editRange");
-  }
-  /** Scans the tree for signs of serious bugs (e.g. this.size doesn't match
-   *  number of elements, internal nodes not caching max element properly...)
-   *  Computational complexity: O(number of nodes), i.e. O(size). This method
-   *  skips the most expensive test - whether all keys are sorted - but it
-   *  does check that maxKey() of the children of internal nodes are sorted. */
-  checkValid() {
-    var size = this._root.checkValid(0, this, 0);
-    check(
-      size === this.size,
-      "size mismatch: counted ",
-      size,
-      "but stored",
-      this.size
-    );
-  }
-  [Symbol.iterator] = this.entries.bind(this);
-  where = this.filter.bind(this);
-  setRange = this.setPairs.bind(this);
-  add = this.set.bind(this);
-  // for compatibility with ISetSink<K>
-};
-function iterator(next = () => ({ done: true, value: void 0 })) {
-  var result = { next };
-  if (Symbol && Symbol.iterator)
-    result[Symbol.iterator] = function() {
+  return [nodeQueue, nodeIndex, nextNode];
+}
+function iterator(next) {
+  return {
+    next,
+    [Symbol.iterator]() {
       return this;
-    };
-  return result;
+    }
+  };
 }
 var BNode = class _BNode {
   // If this is an internal node, _keys[i] is the highest key in children[i].
   keys;
-  values;
   // True if this node might be within multiple `BTree`s (or have multiple parents).
   // If so, it must be cloned before being mutated to avoid changing an unrelated tree.
   // This is transitive: if it's true, children are also shared even if `isShared!=true`
   // in those children. (Certain operations will propagate isShared=true to children.)
   isShared;
-  get isLeaf() {
-    return this.children === void 0;
-  }
-  constructor(keys = [], values) {
+  constructor(keys) {
     this.keys = keys;
-    this.values = values || undefVals;
     this.isShared = void 0;
   }
-  ///////////////////////////////////////////////////////////////////////////
-  // Shared methods /////////////////////////////////////////////////////////
+  isInternal() {
+    return false;
+  }
   maxKey() {
     return this.keys[this.keys.length - 1];
   }
-  // If key not found, returns i^failXor where i is the insertion index.
-  // Callers that don't care whether there was a match will set failXor=0.
-  indexOf(key, failXor, cmp2) {
-    const keys = this.keys;
-    var lo = 0, hi = keys.length, mid = hi >> 1;
-    while (lo < hi) {
-      var c = cmp2(keys[mid], key);
-      if (c < 0)
-        lo = mid + 1;
-      else if (c > 0)
-        hi = mid;
-      else if (c === 0)
-        return mid;
-      else {
-        if (key === key)
-          return keys.length;
-        else
-          throw new Error("BTree: NaN was used as a key");
-      }
-      mid = lo + hi >> 1;
-    }
-    return mid ^ failXor;
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // Leaf Node: misc //////////////////////////////////////////////////////////
   minKey() {
     return this.keys[0];
   }
-  minPair(reusedArray) {
-    if (this.keys.length === 0)
-      return void 0;
-    reusedArray[0] = this.keys[0];
-    reusedArray[1] = this.values[0];
-    return reusedArray;
-  }
-  maxPair(reusedArray) {
-    if (this.keys.length === 0)
-      return void 0;
-    const lastIndex = this.keys.length - 1;
-    reusedArray[0] = this.keys[lastIndex];
-    reusedArray[1] = this.values[lastIndex];
-    return reusedArray;
-  }
   clone() {
-    var v2 = this.values;
-    return new _BNode(
-      this.keys.slice(0),
-      v2 === undefVals ? v2 : v2.slice(0)
-    );
-  }
-  greedyClone(force) {
-    return this.isShared && !force ? this : this.clone();
-  }
-  get(key, defaultValue, tree) {
-    var i = this.indexOf(key, -1, tree._compare);
-    return i < 0 ? defaultValue : this.values[i];
+    return new _BNode(this.keys.slice(0));
   }
-  getPairOrNextLower(key, compare, inclusive, reusedArray) {
-    var i = this.indexOf(key, -1, compare);
-    const indexOrLower = i < 0 ? ~i - 1 : inclusive ? i : i - 1;
-    if (indexOrLower >= 0) {
-      reusedArray[0] = this.keys[indexOrLower];
-      reusedArray[1] = this.values[indexOrLower];
-      return reusedArray;
-    }
-    return void 0;
+  get(key, tree) {
+    const i = indexOf(key, this.keys, -1, tree.comparator);
+    return i < 0 ? void 0 : this.keys[i];
   }
-  getPairOrNextHigher(key, compare, inclusive, reusedArray) {
-    var i = this.indexOf(key, -1, compare);
-    const indexOrLower = i < 0 ? ~i : inclusive ? i : i + 1;
-    const keys = this.keys;
-    if (indexOrLower < keys.length) {
-      reusedArray[0] = keys[indexOrLower];
-      reusedArray[1] = this.values[indexOrLower];
-      return reusedArray;
-    }
-    return void 0;
+  has(key, tree) {
+    const i = indexOf(key, this.keys, -1, tree.comparator);
+    return i >= 0 && i < this.keys.length;
   }
-  checkValid(depth, _tree, baseIndex) {
-    var kL = this.keys.length, vL = this.values.length;
-    check(
-      this.values === undefVals ? kL <= vL : kL === vL,
-      "keys/values length mismatch: depth",
-      depth,
-      "with lengths",
-      kL,
-      vL,
-      "and baseIndex",
-      baseIndex
-    );
-    check(
-      depth == 0 || kL > 0,
-      "empty leaf at depth",
-      depth,
-      "and baseIndex",
-      baseIndex
-    );
-    return kL;
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // Leaf Node: set & node splitting //////////////////////////////////////////
-  set(key, value, overwrite, tree) {
-    var i = this.indexOf(key, -1, tree._compare);
+  set(key, tree) {
+    let i = indexOf(key, this.keys, -1, tree.comparator);
     if (i < 0) {
       i = ~i;
-      tree._size++;
-      if (this.keys.length < tree._maxNodeSize) {
-        return this.insertInLeaf(i, key, value, tree);
-      } else {
-        var newRightSibling = this.splitOffRightSide(), target = this;
-        if (i > this.keys.length) {
-          i -= this.keys.length;
-          target = newRightSibling;
-        }
-        target.insertInLeaf(i, key, value, tree);
-        return newRightSibling;
-      }
-    } else {
-      if (overwrite !== false) {
-        if (value !== void 0)
-          this.reifyValues();
-        this.keys[i] = key;
-        this.values[i] = value;
-      }
-      return false;
-    }
-  }
-  reifyValues() {
-    if (this.values === undefVals)
-      return this.values = this.values.slice(0, this.keys.length);
-    return this.values;
-  }
-  insertInLeaf(i, key, value, tree) {
-    this.keys.splice(i, 0, key);
-    if (this.values === undefVals) {
-      while (undefVals.length < tree._maxNodeSize)
-        undefVals.push(void 0);
-      if (value === void 0) {
-        return true;
-      } else {
-        this.values = undefVals.slice(0, this.keys.length - 1);
+      tree.size++;
+      if (this.keys.length < MAX_NODE_SIZE) {
+        this.keys.splice(i, 0, key);
+        return null;
+      }
+      const newRightSibling = this.splitOffRightSide();
+      let target = this;
+      if (i > this.keys.length) {
+        i -= this.keys.length;
+        target = newRightSibling;
       }
+      target.keys.splice(i, 0, key);
+      return newRightSibling;
     }
-    this.values.splice(i, 0, value);
-    return true;
+    this.keys[i] = key;
+    return null;
   }
   takeFromRight(rhs) {
-    var v2 = this.values;
-    if (rhs.values === undefVals) {
-      if (v2 !== undefVals)
-        v2.push(void 0);
-    } else {
-      v2 = this.reifyValues();
-      v2.push(rhs.values.shift());
-    }
     this.keys.push(rhs.keys.shift());
   }
   takeFromLeft(lhs) {
-    var v2 = this.values;
-    if (lhs.values === undefVals) {
-      if (v2 !== undefVals)
-        v2.unshift(void 0);
-    } else {
-      v2 = this.reifyValues();
-      v2.unshift(lhs.values.pop());
-    }
     this.keys.unshift(lhs.keys.pop());
   }
   splitOffRightSide() {
-    var half = this.keys.length >> 1, keys = this.keys.splice(half);
-    var values = this.values === undefVals ? undefVals : this.values.splice(half);
-    return new _BNode(keys, values);
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // Leaf Node: scanning & deletions //////////////////////////////////////////
-  forRange(low, high, includeHigh, editMode, tree, count, onFound) {
-    var cmp2 = tree._compare;
-    var iLow, iHigh;
-    if (high === low) {
-      if (!includeHigh)
-        return count;
-      iHigh = (iLow = this.indexOf(low, -1, cmp2)) + 1;
-      if (iLow < 0)
-        return count;
-    } else {
-      iLow = this.indexOf(low, 0, cmp2);
-      iHigh = this.indexOf(high, -1, cmp2);
-      if (iHigh < 0)
-        iHigh = ~iHigh;
-      else if (includeHigh === true)
-        iHigh++;
-    }
-    var keys = this.keys, values = this.values;
-    if (onFound !== void 0) {
-      for (var i = iLow; i < iHigh; i++) {
-        var key = keys[i];
-        var result = onFound(key, values[i], count++);
-        if (result !== void 0) {
-          if (editMode === true) {
-            if (key !== keys[i] || this.isShared === true)
-              throw new Error("BTree illegally changed or cloned in editRange");
-            if (result.delete) {
-              this.keys.splice(i, 1);
-              if (this.values !== undefVals)
-                this.values.splice(i, 1);
-              tree._size--;
-              i--;
-              iHigh--;
-            } else if (result.hasOwnProperty("value")) {
-              values[i] = result.value;
-            }
-          }
-          if (result.break !== void 0)
-            return result;
-        }
+    const half = this.keys.length >> 1;
+    const keys = this.keys.splice(half);
+    return new _BNode(keys);
+  }
+  delete(key, tree) {
+    const cmp2 = tree.comparator;
+    const iLow = indexOf(key, this.keys, -1, cmp2);
+    const iHigh = iLow + 1;
+    if (iLow < 0) {
+      return false;
+    }
+    const { keys } = this;
+    for (let i = iLow; i < iHigh; i++) {
+      const key2 = keys[i];
+      if (key2 !== keys[i] || this.isShared === true) {
+        throw new Error("BTree illegally changed or cloned in delete");
       }
-    } else
-      count += iHigh - iLow;
-    return count;
+      this.keys.splice(i, 1);
+      tree.size--;
+      return true;
+    }
+    return false;
   }
-  /** Adds entire contents of right-hand sibling (rhs is left unchanged) */
   mergeSibling(rhs, _) {
-    this.keys.push.apply(this.keys, rhs.keys);
-    if (this.values === undefVals) {
-      if (rhs.values === undefVals)
-        return;
-      this.values = this.values.slice(0, this.keys.length);
-    }
-    this.values.push.apply(this.values, rhs.reifyValues());
+    this.keys.push(...rhs.keys);
   }
 };
 var BNodeInternal = class _BNodeInternal extends BNode {
@@ -13203,187 +12143,75 @@ var BNodeInternal = class _BNodeInternal extends BNode {
   constructor(children, keys) {
     if (!keys) {
       keys = [];
-      for (var i = 0; i < children.length; i++)
+      for (let i = 0; i < children.length; i++) {
         keys[i] = children[i].maxKey();
+      }
     }
     super(keys);
     this.children = children;
   }
+  isInternal() {
+    return true;
+  }
   clone() {
-    var children = this.children.slice(0);
-    for (var i = 0; i < children.length; i++)
+    const children = this.children.slice(0);
+    for (let i = 0; i < children.length; i++) {
       children[i].isShared = true;
+    }
     return new _BNodeInternal(children, this.keys.slice(0));
   }
-  greedyClone(force) {
-    if (this.isShared && !force)
-      return this;
-    var nu = new _BNodeInternal(
-      this.children.slice(0),
-      this.keys.slice(0)
-    );
-    for (var i = 0; i < nu.children.length; i++)
-      nu.children[i] = nu.children[i].greedyClone(force);
-    return nu;
-  }
   minKey() {
     return this.children[0].minKey();
   }
-  minPair(reusedArray) {
-    return this.children[0].minPair(reusedArray);
-  }
-  maxPair(reusedArray) {
-    return this.children[this.children.length - 1].maxPair(reusedArray);
-  }
-  get(key, defaultValue, tree) {
-    var i = this.indexOf(key, 0, tree._compare), children = this.children;
-    return i < children.length ? children[i].get(key, defaultValue, tree) : void 0;
-  }
-  getPairOrNextLower(key, compare, inclusive, reusedArray) {
-    var i = this.indexOf(key, 0, compare), children = this.children;
-    if (i >= children.length)
-      return this.maxPair(reusedArray);
-    const result = children[i].getPairOrNextLower(
-      key,
-      compare,
-      inclusive,
-      reusedArray
-    );
-    if (result === void 0 && i > 0) {
-      return children[i - 1].maxPair(reusedArray);
-    }
-    return result;
-  }
-  getPairOrNextHigher(key, compare, inclusive, reusedArray) {
-    var i = this.indexOf(key, 0, compare), children = this.children, length = children.length;
-    if (i >= length)
-      return void 0;
-    const result = children[i].getPairOrNextHigher(
-      key,
-      compare,
-      inclusive,
-      reusedArray
-    );
-    if (result === void 0 && i < length - 1) {
-      return children[i + 1].minPair(reusedArray);
-    }
-    return result;
-  }
-  checkValid(depth, tree, baseIndex) {
-    let kL = this.keys.length, cL = this.children.length;
-    check(
-      kL === cL,
-      "keys/children length mismatch: depth",
-      depth,
-      "lengths",
-      kL,
-      cL,
-      "baseIndex",
-      baseIndex
-    );
-    check(
-      kL > 1 || depth > 0,
-      "internal node has length",
-      kL,
-      "at depth",
-      depth,
-      "baseIndex",
-      baseIndex
-    );
-    let size = 0, c = this.children, k = this.keys, childSize = 0;
-    for (var i = 0; i < cL; i++) {
-      size += c[i].checkValid(depth + 1, tree, baseIndex + size);
-      childSize += c[i].keys.length;
-      check(size >= childSize, "wtf", baseIndex);
-      check(
-        i === 0 || c[i - 1].constructor === c[i].constructor,
-        "type mismatch, baseIndex:",
-        baseIndex
-      );
-      if (c[i].maxKey() != k[i])
-        check(
-          false,
-          "keys[",
-          i,
-          "] =",
-          k[i],
-          "is wrong, should be ",
-          c[i].maxKey(),
-          "at depth",
-          depth,
-          "baseIndex",
-          baseIndex
-        );
-      if (!(i === 0 || tree._compare(k[i - 1], k[i]) < 0))
-        check(
-          false,
-          "sort violation at depth",
-          depth,
-          "index",
-          i,
-          "keys",
-          k[i - 1],
-          k[i]
-        );
-    }
-    let toofew = childSize === 0;
-    if (toofew || childSize > tree.maxNodeSize * cL)
-      check(
-        false,
-        toofew ? "too few" : "too many",
-        "children (",
-        childSize,
-        size,
-        ") at depth",
-        depth,
-        "maxNodeSize:",
-        tree.maxNodeSize,
-        "children.length:",
-        cL,
-        "baseIndex:",
-        baseIndex
-      );
-    return size;
-  }
-  /////////////////////////////////////////////////////////////////////////////
-  // Internal Node: set & node splitting //////////////////////////////////////
-  set(key, value, overwrite, tree) {
-    var c = this.children, max = tree._maxNodeSize, cmp2 = tree._compare;
-    var i = Math.min(this.indexOf(key, 0, cmp2), c.length - 1), child = c[i];
-    if (child.isShared)
+  get(key, tree) {
+    const i = indexOf(key, this.keys, 0, tree.comparator);
+    const { children } = this;
+    return i < children.length ? children[i].get(key, tree) : void 0;
+  }
+  has(key, tree) {
+    const i = indexOf(key, this.keys, 0, tree.comparator);
+    const { children } = this;
+    return i < children.length ? children[i].has(key, tree) : false;
+  }
+  set(key, tree) {
+    const c = this.children;
+    const cmp2 = tree.comparator;
+    let i = Math.min(indexOf(key, this.keys, 0, cmp2), c.length - 1);
+    let child = c[i];
+    if (child.isShared) {
       c[i] = child = child.clone();
-    if (child.keys.length >= max) {
-      var other;
-      if (i > 0 && (other = c[i - 1]).keys.length < max && cmp2(child.keys[0], key) < 0) {
-        if (other.isShared)
+    }
+    if (child.keys.length >= MAX_NODE_SIZE) {
+      let other;
+      if (i > 0 && (other = c[i - 1]).keys.length < MAX_NODE_SIZE && cmp2(child.keys[0], key) < 0) {
+        if (other.isShared) {
           c[i - 1] = other = other.clone();
+        }
         other.takeFromRight(child);
         this.keys[i - 1] = other.maxKey();
-      } else if ((other = c[i + 1]) !== void 0 && other.keys.length < max && cmp2(child.maxKey(), key) < 0) {
+      } else if ((other = c[i + 1]) !== void 0 && other.keys.length < MAX_NODE_SIZE && cmp2(child.maxKey(), key) < 0) {
         if (other.isShared)
           c[i + 1] = other = other.clone();
         other.takeFromLeft(child);
         this.keys[i] = c[i].maxKey();
       }
     }
-    var result = child.set(key, value, overwrite, tree);
-    if (result === false)
-      return false;
+    const result = child.set(key, tree);
     this.keys[i] = child.maxKey();
-    if (result === true)
-      return true;
-    if (this.keys.length < max) {
+    if (result === null)
+      return null;
+    if (this.keys.length < MAX_NODE_SIZE) {
       this.insert(i + 1, result);
-      return true;
-    } else {
-      var newRightSibling = this.splitOffRightSide(), target = this;
-      if (cmp2(result.maxKey(), this.maxKey()) > 0) {
-        target = newRightSibling;
-        i -= this.keys.length;
-      }
-      target.insert(i + 1, result);
-      return newRightSibling;
+      return null;
     }
+    const newRightSibling = this.splitOffRightSide();
+    let target = this;
+    if (cmp2(result.maxKey(), this.maxKey()) > 0) {
+      target = newRightSibling;
+      i -= this.keys.length;
+    }
+    target.insert(i + 1, result);
+    return newRightSibling;
   }
   /**
    * Inserts `child` at index `i`.
@@ -13399,7 +12227,7 @@ var BNodeInternal = class _BNodeInternal extends BNode {
    * Modifies this to remove the second half of the items, returning a separate node containing them.
    */
   splitOffRightSide() {
-    var half = this.children.length >> 1;
+    const half = this.children.length >> 1;
     return new _BNodeInternal(
       this.children.splice(half),
       this.keys.splice(half)
@@ -13413,76 +12241,42 @@ var BNodeInternal = class _BNodeInternal extends BNode {
     this.keys.unshift(lhs.keys.pop());
     this.children.unshift(lhs.children.pop());
   }
-  /////////////////////////////////////////////////////////////////////////////
-  // Internal Node: scanning & deletions //////////////////////////////////////
-  // Note: `count` is the next value of the third argument to `onFound`.
-  //       A leaf node's `forRange` function returns a new value for this counter,
-  //       unless the operation is to stop early.
-  forRange(low, high, includeHigh, editMode, tree, count, onFound) {
-    var cmp2 = tree._compare;
-    var keys = this.keys, children = this.children;
-    var iLow = this.indexOf(low, 0, cmp2), i = iLow;
-    var iHigh = Math.min(
-      high === low ? iLow : this.indexOf(high, 0, cmp2),
-      keys.length - 1
-    );
-    if (!editMode) {
-      for (; i <= iHigh; i++) {
-        var result = children[i].forRange(
-          low,
-          high,
-          includeHigh,
-          editMode,
-          tree,
-          count,
-          onFound
-        );
-        if (typeof result !== "number")
-          return result;
-        count = result;
-      }
-    } else if (i <= iHigh) {
+  delete(key, tree) {
+    const cmp2 = tree.comparator;
+    const { keys } = this;
+    const { children } = this;
+    let iLow = indexOf(key, this.keys, 0, cmp2);
+    let i = iLow;
+    const iHigh = Math.min(iLow, keys.length - 1);
+    if (i <= iHigh) {
       try {
-        for (; i <= iHigh; i++) {
-          if (children[i].isShared)
-            children[i] = children[i].clone();
-          var result = children[i].forRange(
-            low,
-            high,
-            includeHigh,
-            editMode,
-            tree,
-            count,
-            onFound
-          );
-          keys[i] = children[i].maxKey();
-          if (typeof result !== "number")
-            return result;
-          count = result;
+        if (children[i].isShared) {
+          children[i] = children[i].clone();
         }
+        const result = children[i].delete(key, tree);
+        keys[i] = children[i].maxKey();
+        return result;
       } finally {
-        var half = tree._maxNodeSize >> 1;
+        const half = MAX_NODE_SIZE >> 1;
         if (iLow > 0)
           iLow--;
         for (i = iHigh; i >= iLow; i--) {
           if (children[i].keys.length <= half) {
             if (children[i].keys.length !== 0) {
-              this.tryMerge(i, tree._maxNodeSize);
+              this.tryMerge(i, MAX_NODE_SIZE);
             } else {
               keys.splice(i, 1);
               children.splice(i, 1);
             }
           }
         }
-        if (children.length !== 0 && children[0].keys.length === 0)
-          check(false, "emptiness bug");
       }
     }
-    return count;
+    return false;
   }
   /** Merges child i with child i+1 if their combined size is not too large */
   tryMerge(i, maxSize) {
-    var children = this.children;
+    const { children } = this;
     if (i >= 0 && i + 1 < children.length) {
       if (children[i].keys.length + children[i + 1].keys.length <= maxSize) {
         if (children[i].isShared)
@@ -13502,39 +12296,42 @@ var BNodeInternal = class _BNodeInternal extends BNode {
    * (otherwise isShared for its children could be incorrect).
    */
   mergeSibling(rhs, maxNodeSize) {
-    var oldLength = this.keys.length;
-    this.keys.push.apply(this.keys, rhs.keys);
+    const oldLength = this.keys.length;
+    this.keys.push(...rhs.keys);
     const rhsChildren = rhs.children;
-    this.children.push.apply(this.children, rhsChildren);
+    this.children.push(...rhsChildren);
     if (rhs.isShared && !this.isShared) {
-      for (var i = 0; i < rhsChildren.length; i++)
+      for (let i = 0; i < rhsChildren.length; i++) {
         rhsChildren[i].isShared = true;
+      }
     }
     this.tryMerge(oldLength - 1, maxNodeSize);
   }
 };
-var undefVals = [];
-var Delete = { delete: true };
-var DeleteRange = () => Delete;
-var Break = { break: true };
-var EmptyLeaf = function() {
-  var n = new BNode();
-  n.isShared = true;
-  return n;
-}();
-var EmptyArray = [];
-var ReusedArray = [];
-function check(fact, ...args) {
-  if (!fact) {
-    args.unshift("B+ tree");
-    throw new Error(args.join(" "));
-  }
-}
-var EmptyBTree = (() => {
-  let t2 = new BTree();
-  t2.freeze();
-  return t2;
-})();
+function indexOf(key, keys, failXor, comparator2) {
+  let lo = 0;
+  let hi = keys.length;
+  let mid = hi >> 1;
+  while (lo < hi) {
+    const c = comparator2(keys[mid], key);
+    if (c < 0) {
+      lo = mid + 1;
+    } else if (c > 0) {
+      hi = mid;
+    } else if (c === 0) {
+      return mid;
+    } else {
+      if (key === key) {
+        return keys.length;
+      }
+      throw new Error("NaN was used as a key");
+    }
+    mid = lo + hi >> 1;
+  }
+  return mid ^ failXor;
+}
+var emptyLeaf = new BNode([]);
+emptyLeaf.isShared = true;
 
 // ../zql/src/ivm/constraint.ts
 function constraintMatchesRow(constraint, row) {
@@ -13573,10 +12370,10 @@ var MemorySource = class {
     this.#columns = columns;
     this.#primaryKey = primaryKey;
     this.#primaryIndexSort = primaryKey.map((k) => [k, "asc"]);
-    const comparator = makeBoundComparator(this.#primaryIndexSort);
+    const comparator2 = makeBoundComparator(this.#primaryIndexSort);
     this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {
-      comparator,
-      data: new BTree([], comparator),
+      comparator: comparator2,
+      data: new BTreeSet(comparator2),
       usedBy: /* @__PURE__ */ new Set()
     });
     assertOrderingIncludesPK(this.#primaryIndexSort, this.#primaryKey);
@@ -13658,12 +12455,12 @@ var MemorySource = class {
       index.usedBy.add(usedBy);
       return index;
     }
-    const comparator = makeBoundComparator(sort);
-    const data = new BTree([], comparator);
-    for (const row of this.#getPrimaryIndex().data.keys()) {
-      data.add(row, void 0);
+    const comparator2 = makeBoundComparator(sort);
+    const data = new BTreeSet(comparator2);
+    for (const row of this.#getPrimaryIndex().data) {
+      data.add(row);
     }
-    const newIndex = { comparator, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
+    const newIndex = { comparator: comparator2, data, usedBy: /* @__PURE__ */ new Set([usedBy]) };
     this.#indexes.set(key, newIndex);
     return newIndex;
   }
@@ -13688,7 +12485,7 @@ var MemorySource = class {
     }
     const index = this.#getOrCreateIndex(indexSort, from);
     const { data, comparator: compare } = index;
-    const comparator = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
+    const comparator2 = (r1, r2) => compare(r1, r2) * (req.reverse ? -1 : 1);
     if (this.#overlay) {
       if (callingConnectionNum <= this.#overlay.outputIndex) {
         overlay = this.#overlay;
@@ -13717,11 +12514,11 @@ var MemorySource = class {
       generateRows(data, scanStart, req.reverse),
       req.constraint,
       overlay,
-      comparator,
+      comparator2,
       conn.filters?.predicate
     );
     const withConstraint = generateWithConstraint(
-      generateWithStart(withOverlay, req.start, comparator),
+      generateWithStart(withOverlay, req.start, comparator2),
       req.constraint
     );
     yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
@@ -13786,7 +12583,7 @@ var MemorySource = class {
     for (const { data: data2 } of this.#indexes.values()) {
       switch (change.type) {
         case "add": {
-          const added = data2.add(change.row, void 0);
+          const added = data2.add(change.row);
           assert(added);
           break;
         }
@@ -13798,7 +12595,7 @@ var MemorySource = class {
         case "edit": {
           const removed = data2.delete(change.oldRow);
           assert(removed);
-          data2.add(change.row, void 0);
+          data2.add(change.row);
           break;
         }
         default:
@@ -13969,40 +12766,43 @@ function compareBounds(a, b) {
   return compareValues(a, b);
 }
 function* generateRows(data, scanStart, reverse) {
-  for (const entry of data[reverse ? "entriesReversed" : "entries"](
-    scanStart,
-    []
-  )) {
-    yield entry[0];
-  }
+  yield* data[reverse ? "valuesFromReversed" : "valuesFrom"](
+    scanStart
+  );
 }
 
 // ../zql/src/ivm/memory-storage.ts
+import { compareUTF8 as compareUTF85 } from "compare-utf8";
+function comparator(a, b) {
+  return compareUTF85(a[0], b[0]);
+}
 var MemoryStorage = class {
-  #data = new BTree();
+  #data = new BTreeSet(comparator);
   set(key, value) {
-    this.#data.add(key, value);
+    this.#data.add([key, value]);
   }
   get(key, def) {
-    const r = this.#data.get(key);
+    const r = this.#data.get([key, null]);
     if (r !== void 0) {
-      return r;
+      return r[1];
     }
     return def;
   }
   del(key) {
-    this.#data.delete(key);
+    this.#data.delete([key, null]);
   }
   *scan(options) {
-    for (const [key, value] of this.#data.entries(options?.prefix)) {
-      if (options && !key.startsWith(options.prefix)) {
+    for (const entry of this.#data.valuesFrom(
+      options && [options.prefix, null]
+    )) {
+      if (options && !entry[0].startsWith(options.prefix)) {
         return;
       }
-      yield [key, value];
+      yield entry;
     }
   }
   cloneData() {
-    return structuredClone(Object.fromEntries(this.#data.entries()));
+    return structuredClone(Object.fromEntries(this.#data.values()));
   }
 };
 
@@ -14046,7 +12846,7 @@ var ZeroContext = class {
   #commitListeners = /* @__PURE__ */ new Set();
   staticQueryParameters = void 0;
   constructor(tables, addQuery, batchViewUpdates) {
-    this.#tables = normalizeTables(tables);
+    this.#tables = tables;
     this.#addQuery = addQuery;
     this.#batchViewUpdates = batchViewUpdates;
   }
@@ -14597,7 +13397,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.11.2025011402+73df1d";
+var version2 = "0.11.2025011801+0c3f2d";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15656,15 +14456,14 @@ var Zero = class {
       enableAnalytics: this.#enableAnalytics
     });
     const logOptions = this.#logOptions;
-    const normalizedSchema = normalizeSchema(schema);
     const replicacheMutators = {
-      ["_zero_crud"]: makeCRUDMutator(normalizedSchema)
+      ["_zero_crud"]: makeCRUDMutator(schema)
     };
     this.storageKey = storageKey ?? "";
     const replicacheOptions = {
       // The schema stored in IDB is dependent upon both the application schema
       // and the AST schema (i.e. PROTOCOL_VERSION).
-      schemaVersion: `${normalizedSchema.version}.${PROTOCOL_VERSION}`,
+      schemaVersion: `${schema.version}.${PROTOCOL_VERSION}`,
       logLevel: logOptions.logLevel,
       logSinks: [logOptions.logSink],
       mutators: replicacheMutators,
@@ -15715,10 +14514,7 @@ var Zero = class {
     });
     this.#onClientStateNotFound = onClientStateNotFoundCallback;
     this.#rep.onClientStateNotFound = onClientStateNotFoundCallback;
-    const { mutate, mutateBatch } = makeCRUDMutate(
-      normalizedSchema,
-      rep.mutate
-    );
+    const { mutate, mutateBatch } = makeCRUDMutate(schema, rep.mutate);
     this.mutate = mutate;
     this.mutateBatch = mutateBatch;
     this.#queryManager = new QueryManager(
@@ -15728,7 +14524,7 @@ var Zero = class {
       maxRecentQueries
     );
     this.#zeroContext = new ZeroContext(
-      normalizedSchema.tables,
+      schema.tables,
       (ast, gotCallback) => this.#queryManager.add(ast, gotCallback),
       batchViewUpdates
     );
@@ -15739,7 +14535,7 @@ var Zero = class {
         initialValuesInFirstDiff: true
       }
     );
-    this.query = this.#registerQueries(normalizedSchema);
+    this.query = this.#registerQueries(schema);
     reportReloadReason(this.#lc);
     this.#metrics = new MetricManager({
       reportIntervalMs: REPORT_INTERVAL_MS,
@@ -15753,7 +14549,7 @@ var Zero = class {
       (poke) => this.#rep.poke(poke),
       () => this.#onPokeError(),
       rep.clientID,
-      normalizedSchema,
+      schema,
       this.#lc
     );
     this.#visibilityWatcher = getDocumentVisibilityWatcher(
@@ -16559,8 +15355,8 @@ var Zero = class {
   #registerQueries(schema) {
     const rv = {};
     const context = this.#zeroContext;
-    for (const [name, table] of Object.entries(schema.tables)) {
-      rv[name] = newQuery(context, table);
+    for (const name of Object.keys(schema.tables)) {
+      rv[name] = newQuery(context, schema, name);
     }
     return rv;
   }
@@ -16628,13 +15424,18 @@ export {
   makeIDBName,
   dropDatabase,
   dropAllDatabases,
-  column_exports,
-  createTableSchema,
   ANYONE_CAN,
   NOBODY_CAN,
   definePermissions,
+  table,
+  string8 as string,
+  number5 as number,
+  boolean4 as boolean,
+  json,
+  enumeration,
   createSchema,
+  relationships,
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-AII6TS5B.js.map
+//# sourceMappingURL=chunk-QV5ZN4MA.js.map