@suss/datalog 0.37.1 → 0.38.1

package/dist/index.js

@@ -1,43 +1,91 @@
 // src/factIndex.ts
-var emptyNode = () => ({
-  present: false,
-  tag: void 0,
-  next: void 0
-});
+var FactKey = class {
+  constructor(tuple) {
+    this.tuple = tuple;
+  }
+  tuple;
+  present = false;
+  tag = void 0;
+};
+var Branch = class {
+  /** The key of a tuple that ends at this column, as a shorter one in a relation of mixed arity does. */
+  here = void 0;
+  next = /* @__PURE__ */ new Map();
+};
+function sameFrom(a, b, from) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let at = from; at < a.length; at++) {
+    if (a[at] !== b[at]) {
+      return false;
+    }
+  }
+  return true;
+}
+function place(branch, key, depth) {
+  if (depth === key.tuple.length) {
+    branch.here = key;
+  } else {
+    branch.next.set(key.tuple[depth], key);
+  }
+}
+function soleKey(branch) {
+  if (branch.here !== void 0) {
+    return branch.next.size === 0 ? branch.here : void 0;
+  }
+  if (branch.next.size !== 1) {
+    return void 0;
+  }
+  const only = branch.next.values().next().value;
+  return only instanceof FactKey ? only : void 0;
+}
 var FactIndex = class {
   /** How many facts are present. */
   size = 0;
-  root = emptyNode();
+  root = new Branch();
   /** This tuple's key here, whether or not the fact is present. */
   key(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      let next = node.next;
-      if (next === void 0) {
-        next = /* @__PURE__ */ new Map();
-        node.next = next;
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      if (depth === tuple.length) {
+        branch.here ??= new FactKey(tuple);
+        return branch.here;
       }
-      const atom = tuple[i];
-      let child = next.get(atom);
+      const atom = tuple[depth];
+      const child = branch.next.get(atom);
       if (child === void 0) {
-        child = emptyNode();
-        next.set(atom, child);
+        const key = new FactKey(tuple);
+        branch.next.set(atom, key);
+        return key;
       }
-      node = child;
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (sameFrom(child.tuple, tuple, depth + 1)) {
+        return child;
+      }
+      const split = new Branch();
+      place(split, child, depth + 1);
+      branch.next.set(atom, split);
+      branch = split;
     }
-    return node;
   }
   /** The key of a fact this relation has, or undefined when it has none. */
   find(tuple) {
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    let branch = this.root;
+    for (let depth = 0; ; depth++) {
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return void 0;
       }
-      node = child;
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      return child.present && sameFrom(child.tuple, tuple, depth + 1) ? child : void 0;
     }
-    return node.present ? node : void 0;
   }
   has(key) {
     return key.present;
@@ -61,32 +109,45 @@ var FactIndex = class {
     this.size -= 1;
   }
   /**
-   * Drop what is left of a removed tuple's path, up to the first node
-   * another fact still needs. Without this a relation that is retracted
-   * from over and over keeps a node per tuple it ever had.
+   * Drop a removed tuple's key, and any branch left with one key to
+   * tell apart. Without this a relation that is retracted from over and
+   * over keeps a key per tuple it ever had.
    */
   prune(tuple) {
-    const path = [this.root];
-    let node = this.root;
-    for (let i = 0; i < tuple.length; i++) {
-      const child = node.next?.get(tuple[i]);
+    const path = [];
+    let branch = this.root;
+    let depth = 0;
+    for (; ; depth++) {
+      path.push(branch);
+      const child = depth === tuple.length ? branch.here : branch.next.get(tuple[depth]);
       if (child === void 0) {
         return;
       }
-      node = child;
-      path.push(child);
+      if (child instanceof Branch) {
+        branch = child;
+        continue;
+      }
+      if (child.present || !sameFrom(child.tuple, tuple, depth + 1)) {
+        return;
+      }
+      break;
+    }
+    if (depth === tuple.length) {
+      branch.here = void 0;
+    } else {
+      branch.next.delete(tuple[depth]);
     }
-    for (let i = path.length - 1; i > 0; i--) {
-      const child = path[i];
-      if (child.present || (child.next?.size ?? 0) > 0) {
+    for (let at = path.length - 1; at > 0; at--) {
+      const sole = soleKey(path[at]);
+      if (sole === void 0) {
         return;
       }
-      path[i - 1].next?.delete(tuple[i - 1]);
+      path[at - 1].next.set(tuple[at - 1], sole);
     }
   }
   /** Drop every fact, and whatever was kept in order to find them. */
   clear() {
-    this.root = emptyNode();
+    this.root = new Branch();
     this.size = 0;
   }
 };
@@ -523,6 +584,24 @@ function formatProfile(profile) {
 }
 
 // src/relation.ts
+var isLone = (bucket) => typeof bucket[0] !== "object";
+var NO_TUPLES = [];
+function tuplesIn(bucket) {
+  if (bucket === void 0) {
+    return NO_TUPLES;
+  }
+  return isLone(bucket) ? [bucket] : bucket;
+}
+function fileUnder(buckets, key, tuple) {
+  const bucket = buckets.get(key);
+  if (bucket === void 0) {
+    buckets.set(key, tuple);
+  } else if (isLone(bucket)) {
+    buckets.set(key, [bucket, tuple]);
+  } else {
+    bucket.push(tuple);
+  }
+}
 var sameTuple = (a, b) => a.length === b.length && a.every((atom, at) => atom === b[at]);
 function storedTuplesOf(relation, facts) {
   const column = relation.columns.findIndex((buckets2) => buckets2 !== void 0);
@@ -531,19 +610,24 @@ function storedTuplesOf(relation, facts) {
     return null;
   }
   const stored = facts.map(
-    (fact) => buckets.get(fact[column])?.find((tuple) => sameTuple(tuple, fact))
+    (fact) => tuplesIn(buckets.get(fact[column])).find(
+      (tuple) => sameTuple(tuple, fact)
+    )
   );
   return stored.every((tuple) => tuple !== void 0) ? stored : null;
 }
 function removeFrom(buckets, key, tuple) {
   const bucket = buckets.get(key);
-  const at = bucket?.indexOf(tuple) ?? -1;
-  if (bucket === void 0 || at === -1) {
+  if (bucket === void 0) {
     return;
   }
-  bucket.splice(at, 1);
-  if (bucket.length === 0) {
+  if (isLone(bucket)) {
     buckets.delete(key);
+    return;
+  }
+  bucket.splice(bucket.indexOf(tuple), 1);
+  if (bucket.length === 1) {
+    buckets.set(key, bucket[0]);
   }
 }
 function removeTuples(relation, stored) {
@@ -595,7 +679,7 @@ function addToCombined(index, tuple) {
     }
     level = next;
   }
-  addToBucket(
+  fileUnder(
     level,
     tuple[index.columns[last]],
     tuple
@@ -614,10 +698,10 @@ function combinedBucketIn(relation, mask, values) {
   for (const value of values) {
     level = level.get(value);
     if (level === void 0) {
-      return [];
+      return NO_TUPLES;
     }
   }
-  return level;
+  return tuplesIn(level);
 }
 function addToBucket(buckets, key, tuple) {
   const bucket = buckets.get(key);
@@ -627,19 +711,291 @@ function addToBucket(buckets, key, tuple) {
     bucket.push(tuple);
   }
 }
-function bucketIn(relation, column, value) {
+function columnIndex(relation, column) {
   let buckets = relation.columns[column];
   if (buckets === void 0) {
     buckets = /* @__PURE__ */ new Map();
     for (const tuple of relation.tuples) {
       const at = tuple[column];
       if (at !== void 0) {
-        addToBucket(buckets, at, tuple);
+        fileUnder(buckets, at, tuple);
       }
     }
     relation.columns[column] = buckets;
   }
-  return buckets.get(value) ?? [];
+  return buckets;
+}
+function bucketIn(relation, column, value) {
+  return tuplesIn(columnIndex(relation, column).get(value));
+}
+function bucketSize(relation, column, value) {
+  const bucket = columnIndex(relation, column).get(value);
+  if (bucket === void 0) {
+    return 0;
+  }
+  return isLone(bucket) ? 1 : bucket.length;
+}
+
+// src/reads.ts
+function noteIn(reads, column, value) {
+  if (reads.whole) {
+    return;
+  }
+  let values = reads.columns[column];
+  if (values === void 0) {
+    values = /* @__PURE__ */ new Set();
+    reads.columns[column] = values;
+  }
+  values.add(value);
+}
+var ReadLog = class {
+  constructor(skipped) {
+    this.skipped = skipped;
+  }
+  skipped;
+  /** Null for a relation the caller said to leave out. */
+  byRelation = /* @__PURE__ */ new Map();
+  lookedUp(relation, column, value) {
+    const reads = this.readsOf(relation);
+    if (reads !== null) {
+      noteIn(reads, column, value);
+    }
+  }
+  readWhole(relation) {
+    const reads = this.readsOf(relation);
+    if (reads !== null) {
+      reads.whole = true;
+    }
+  }
+  /** Note everything an inner log noted, for an answer cached inside another. */
+  absorb(inner) {
+    for (const [relation, reads] of inner.byRelation) {
+      if (reads === null) {
+        continue;
+      }
+      if (reads.whole) {
+        this.readWhole(relation);
+        continue;
+      }
+      reads.columns.forEach((values, column) => {
+        for (const value of values ?? []) {
+          this.lookedUp(relation, column, value);
+        }
+      });
+    }
+  }
+  /**
+   * The reads with what each one finds in `db` now. One question looks
+   * up the same values in many columns, so each value is kept once, and
+   * each column keeps a bit per value saying whether it was looked up
+   * there.
+   */
+  counted(db) {
+    const names = [];
+    const groups = [];
+    const columns = [];
+    const lookedUp = [];
+    const positions = /* @__PURE__ */ new Map();
+    const values = [];
+    const addGroup = (column, seen) => {
+      groups.push(names.length - 1);
+      columns.push(column);
+      lookedUp.push(seen);
+      for (const value of seen) {
+        if (!positions.has(value)) {
+          positions.set(value, values.length);
+          values.push(value);
+        }
+      }
+    };
+    for (const [relation, reads] of this.byRelation) {
+      if (reads === null) {
+        continue;
+      }
+      names.push(relation);
+      if (reads.whole) {
+        addGroup(WHOLE, NONE);
+        continue;
+      }
+      reads.columns.forEach((seen, column) => {
+        if (seen !== void 0) {
+          addGroup(column, seen);
+        }
+      });
+    }
+    const words = Math.ceil(values.length / 32);
+    const bits = new Uint32Array(groups.length * words);
+    let found = 0;
+    lookedUp.forEach((seen, group) => {
+      const relation = db.relationOf(names[groups[group]]);
+      const column = columns[group];
+      if (column === WHOLE) {
+        found += relation?.tuples.length ?? 0;
+      }
+      for (const value of seen) {
+        const at = positions.get(value);
+        bits[group * words + (at >>> 5)] |= 1 << (at & 31);
+        found += relation === void 0 ? 0 : bucketSize(relation, column, value);
+      }
+    });
+    return new ReadsNoted(
+      db,
+      this.skipped,
+      { names, groups, columns, values, bits },
+      found
+    );
+  }
+  /** @internal Null for a relation the caller said to leave out. */
+  readsOf(relation) {
+    let reads = this.byRelation.get(relation);
+    if (reads === void 0) {
+      reads = this.skipped.has(relation) ? null : { whole: false, columns: [] };
+      this.byRelation.set(relation, reads);
+    }
+    return reads;
+  }
+};
+var WHOLE = -1;
+var NONE = /* @__PURE__ */ new Set();
+var ReadsNoted = class {
+  constructor(db, skipped, lookups, found) {
+    this.skipped = skipped;
+    this.found = found;
+    this.names = lookups.names;
+    this.groups = lookups.groups;
+    this.columns = lookups.columns;
+    this.values = lookups.values;
+    this.bits = lookups.bits;
+    this.words = Math.ceil(lookups.values.length / 32);
+    this.relations = lookups.names.map((name) => db.relationOf(name));
+    this.removed = this.sumOver(db, removedFrom);
+    this.facts = this.sumOver(db, factsIn);
+  }
+  skipped;
+  found;
+  names;
+  groups;
+  columns;
+  values;
+  bits;
+  words;
+  removed;
+  /** The facts in every relation read, when the counts last matched. */
+  facts;
+  /** Each relation read, found by name the first time a check needs it. */
+  relations;
+  /**
+   * Whether every read would find what it found then. A fact left in a
+   * skipped relation would join a question asked now without anything
+   * here having looked it up, so one there makes the answer no. The
+   * counts are taken again only when a relation read has grown.
+   */
+  unchangedIn(db) {
+    if (!allEmpty(db, this.skipped)) {
+      return false;
+    }
+    if (this.sumOver(db, removedFrom) !== this.removed) {
+      return false;
+    }
+    const facts = this.sumOver(db, factsIn);
+    if (facts === this.facts) {
+      return true;
+    }
+    if (this.countIn(db, this.found) !== this.found) {
+      return false;
+    }
+    this.facts = facts;
+    return true;
+  }
+  relationAt(db, at) {
+    let relation = this.relations[at];
+    if (relation === void 0) {
+      relation = db.relationOf(this.names[at]);
+      this.relations[at] = relation;
+    }
+    return relation;
+  }
+  sumOver(db, measure) {
+    let sum = 0;
+    for (let at = 0; at < this.names.length; at++) {
+      const relation = this.relationAt(db, at);
+      sum += relation === void 0 ? 0 : measure(relation);
+    }
+    return sum;
+  }
+  /**
+   * The facts the reads find, stopping once past `limit`. With nothing
+   * retracted every count only grows, so passing the old total already
+   * says that one of them grew.
+   */
+  countIn(db, limit) {
+    let found = 0;
+    for (let group = 0; group < this.groups.length && found <= limit; group++) {
+      const relation = this.relationAt(db, this.groups[group]);
+      const column = this.columns[group];
+      if (column === WHOLE) {
+        found += relation?.tuples.length ?? 0;
+      } else if (relation !== void 0) {
+        found += this.countGroup(relation, group, column);
+      }
+    }
+    return found;
+  }
+  countGroup(relation, group, column) {
+    let found = 0;
+    const first = group * this.words;
+    for (let word = 0; word < this.words; word++) {
+      let left = this.bits[first + word];
+      while (left !== 0) {
+        const bit = 31 - Math.clz32(left & -left);
+        left &= left - 1;
+        const value = this.values[word * 32 + bit];
+        found += bucketSize(relation, column, value);
+      }
+    }
+    return found;
+  }
+};
+var removedFrom = (relation) => relation.removed;
+var factsIn = (relation) => relation.tuples.length;
+var skippedIn = /* @__PURE__ */ new WeakMap();
+function allEmpty(db, skipped) {
+  let bySet = skippedIn.get(db);
+  if (bySet === void 0) {
+    bySet = /* @__PURE__ */ new WeakMap();
+    skippedIn.set(db, bySet);
+  }
+  let known = bySet.get(skipped);
+  if (known === void 0) {
+    known = { found: [], missing: [...skipped] };
+    bySet.set(skipped, known);
+  }
+  if (known.missing.length > 0) {
+    const stillMissing = [];
+    for (const name of known.missing) {
+      const relation = db.relationOf(name);
+      if (relation === void 0) {
+        stillMissing.push(name);
+      } else {
+        known.found.push(relation);
+      }
+    }
+    known.missing = stillMissing;
+  }
+  return known.found.every((relation) => relation.tuples.length === 0);
+}
+function noteReads(db, skipped, work) {
+  const outer = db.readLog;
+  const log = new ReadLog(skipped);
+  const emptyAtStart = allEmpty(db, skipped);
+  db.readLog = log;
+  try {
+    const value = work();
+    return { value, reads: emptyAtStart ? log.counted(db) : null };
+  } finally {
+    db.readLog = outer;
+    outer?.absorb(log);
+  }
 }
 
 // src/stratum.ts
@@ -665,7 +1021,7 @@ function planStratum(rules) {
   }
   return { rules, derived, readers, marked: new Uint8Array(rules.length) };
 }
-var NONE = [];
+var NONE2 = [];
 function rulesReading(stratum, seed, derivedOnly) {
   const lists = [];
   for (const [relation, tuples] of seed) {
@@ -681,7 +1037,7 @@ function rulesReading(stratum, seed, derivedOnly) {
     }
   }
   if (lists.length === 0) {
-    return NONE;
+    return NONE2;
   }
   if (lists.length === 1) {
     return lists[0];
@@ -851,6 +1207,8 @@ var ruleLabel = (r) => r.name ?? `${r.head.relation} :- ${r.body.map(literalName
 var FEW_REMOVED = 16;
 var Database = class {
   store = /* @__PURE__ */ new Map();
+  /** @internal Where reads are noted while `noteReads` runs. */
+  readLog = null;
   relation(name) {
     const existing = this.store.get(name);
     if (existing !== void 0) {
@@ -860,7 +1218,8 @@ var Database = class {
       index: new FactIndex(),
       tuples: [],
       columns: [],
-      combined: /* @__PURE__ */ new Map()
+      combined: /* @__PURE__ */ new Map(),
+      removed: 0
     };
     this.store.set(name, created);
     return created;
@@ -905,7 +1264,7 @@ var Database = class {
       const buckets = relation.columns[column];
       const value = tuple[column];
       if (buckets !== void 0 && value !== void 0) {
-        addToBucket(buckets, value, tuple);
+        fileUnder(buckets, value, tuple);
       }
     }
     for (const combined of relation.combined.values()) {
@@ -915,6 +1274,7 @@ var Database = class {
   }
   /** The tag stored for this fact, or undefined when there is none. */
   tagOf(relationName, tuple) {
+    this.noteTupleRead(relationName, tuple);
     const relation = this.store.get(relationName);
     if (relation === void 0) {
       return void 0;
@@ -923,9 +1283,20 @@ var Database = class {
     return key === void 0 ? void 0 : relation.index.tagOf(key);
   }
   has(relationName, tuple) {
+    this.noteTupleRead(relationName, tuple);
     return this.store.get(relationName)?.index.find(tuple) !== void 0;
   }
+  /** A fact matching the whole tuple agrees on its first column, so that lookup is enough to note. */
+  noteTupleRead(relationName, tuple) {
+    const first = tuple[0];
+    if (first === void 0) {
+      this.readLog?.readWhole(relationName);
+      return;
+    }
+    this.readLog?.lookedUp(relationName, 0, first);
+  }
   facts(relationName) {
+    this.readLog?.readWhole(relationName);
     return this.store.get(relationName)?.tuples ?? [];
   }
   /**
@@ -938,6 +1309,7 @@ var Database = class {
    * gets an index.
    */
   lookup(relationName, column, value) {
+    this.readLog?.lookedUp(relationName, column, value);
     const relation = this.store.get(relationName);
     return relation === void 0 ? [] : bucketIn(relation, column, value);
   }
@@ -973,6 +1345,7 @@ var Database = class {
     for (const key of going) {
       index.remove(key);
     }
+    relation.removed += going.size;
     if (index.size === 0) {
       relation.tuples = [];
       index.clear();
@@ -1008,6 +1381,7 @@ var Database = class {
       return 0;
     }
     const removed = relation.tuples.length;
+    relation.removed += removed;
     relation.tuples = [];
     relation.index.clear();
     relation.columns.length = 0;
@@ -1016,12 +1390,15 @@ var Database = class {
     return removed;
   }
   size(relationName) {
-    return this.store.get(relationName)?.tuples.length ?? 0;
+    this.readLog?.readWhole(relationName);
+    return sizeOf(this, relationName);
   }
   relationNames() {
     return [...this.store.keys()];
   }
 };
+var tuplesOf = (db, relation) => db.relationOf(relation)?.tuples ?? [];
+var sizeOf = (db, relation) => db.relationOf(relation)?.tuples.length ?? 0;
 function rulesDeriving(rules, relations) {
   const wanted = new Set(relations);
   const pending = [...relations];
@@ -1217,6 +1594,7 @@ function evaluateRule(db, deltas, r, deltaIndex, budget) {
   }
   const byValue = newFactsByColumn(rows, start.column, budget);
   const first = body[start.index];
+  noteSharedLookups(db, first, start, rows);
   for (const tuple of start.source) {
     budget.examined++;
     if (budget.examined > budget.limit) {
@@ -1248,7 +1626,7 @@ function smallerStart(db, body, deltaAt, rows) {
     if (column === -1) {
       continue;
     }
-    const source = narrowedSource(db, literal, null) ?? db.facts(literal.relation);
+    const source = narrowedSource(db, literal, null) ?? tuplesOf(db, literal.relation);
     const worthIt = indexed?.has(column) ? source.length < rows.length : source.length * 2 < rows.length;
     if (worthIt && (best === null || source.length < best.source.length)) {
       best = {
@@ -1306,6 +1684,7 @@ function nextLiteral(db, body, taken, bindings) {
       continue;
     }
     if (source.length === 0) {
+      noteLookup(db, literal, bindings);
       return -1;
     }
     if (narrowest === null || source.length < narrowest.length) {
@@ -1314,6 +1693,7 @@ function nextLiteral(db, body, taken, bindings) {
     }
   }
   if (narrowest !== null) {
+    noteLookup(db, body[pick], bindings);
     nextSource = narrowedFurther(db, body[pick], bindings, narrowest);
     return nextSource.length === 0 ? -1 : pick;
   }
@@ -1325,6 +1705,59 @@ function nextLiteral(db, body, taken, bindings) {
   }
   return body.findIndex((_, index) => !(taken & 1 << index));
 }
+function noteLookup(db, literal, bindings) {
+  const reads = db.readLog?.readsOf(literal.relation) ?? null;
+  if (reads === null) {
+    return;
+  }
+  for (let column2 = 0; column2 < literal.terms.length; column2++) {
+    const term2 = literal.terms[column2];
+    if (term2.type === "variable") {
+      const value = boundValue(bindings, term2.name);
+      if (value !== void 0) {
+        noteIn(reads, column2, value);
+        return;
+      }
+    }
+  }
+  const column = fewestFactsUnderConstant(db, literal);
+  const term = literal.terms[column];
+  if (term?.type === "constant") {
+    noteIn(reads, column, term.value);
+  }
+}
+function fewestFactsUnderConstant(db, literal) {
+  const relation = db.relationOf(literal.relation);
+  let best = -1;
+  let bestFacts = Number.POSITIVE_INFINITY;
+  for (let column = 0; column < literal.terms.length; column++) {
+    const term = literal.terms[column];
+    if (term.type !== "constant") {
+      continue;
+    }
+    const facts = relation === void 0 ? 0 : bucketSize(relation, column, term.value);
+    if (facts < bestFacts) {
+      best = column;
+      bestFacts = facts;
+    }
+  }
+  return best;
+}
+function noteSharedLookups(db, first, start, rows) {
+  const reads = db.readLog?.readsOf(first.relation) ?? null;
+  if (reads === null) {
+    return;
+  }
+  const column = first.terms.findIndex(
+    (term) => term.type === "variable" && term.name === start.variable
+  );
+  for (const row of rows) {
+    const value = row[start.column];
+    if (value !== void 0) {
+      noteIn(reads, column, value);
+    }
+  }
+}
 function narrowedSource(db, literal, bindings) {
   const relation = db.relationOf(literal.relation);
   let narrowest = null;
@@ -1376,7 +1809,11 @@ function constantColumnsOf(literal) {
         values.push(term.value);
       }
     });
-    known = columns.length === 0 ? null : { columns, values };
+    known = columns.length === 0 ? null : {
+      columns,
+      values,
+      bucketKey: deltaBucketKey(literal.relation, columns[0])
+    };
     constantColumns.set(literal, known);
   }
   return known;
@@ -1389,7 +1826,7 @@ function hasNoNewRows(deltas, literal) {
   if (rows.length === 0 || constants === null) {
     return rows.length === 0;
   }
-  const buckets = deltaBuckets.get(deltas)?.get(deltaBucketKey(literal.relation, constants.columns[0]));
+  const buckets = deltaBuckets.get(deltas)?.get(constants.bucketKey);
   return buckets !== void 0 && !buckets.has(constants.values[0]);
 }
 function deltaRows(deltas, literal, budget) {
@@ -1404,7 +1841,7 @@ function deltaRows(deltas, literal, budget) {
     deltaBuckets.set(deltas, byColumn);
   }
   const column = constants.columns[0];
-  const key = deltaBucketKey(literal.relation, column);
+  const key = constants.bucketKey;
   let buckets = byColumn.get(key);
   if (buckets === void 0) {
     buckets = /* @__PURE__ */ new Map();
@@ -1549,7 +1986,7 @@ function canResume(rules, state) {
 function factsSince(db, marks) {
   const added = /* @__PURE__ */ new Map();
   for (const name of db.relationNames()) {
-    const all = db.facts(name);
+    const all = tuplesOf(db, name);
     const mark = marks.get(name) ?? 0;
     if (all.length > mark) {
       added.set(name, all.slice(mark));
@@ -1560,7 +1997,7 @@ function factsSince(db, marks) {
 function currentMarks(db) {
   const marks = /* @__PURE__ */ new Map();
   for (const name of db.relationNames()) {
-    marks.set(name, db.size(name));
+    marks.set(name, sizeOf(db, name));
   }
   return marks;
 }
@@ -1622,9 +2059,14 @@ function shapeOf(rules) {
   return shape;
 }
 function couldProduce(db, rule2) {
-  return rule2.body.every(
-    (literal) => literal.negated || db.size(literal.relation) > 0
+  const empty = rule2.body.find(
+    (literal) => !literal.negated && sizeOf(db, literal.relation) === 0
   );
+  if (empty === void 0) {
+    return true;
+  }
+  db.readLog?.readWhole(empty.relation);
+  return false;
 }
 function storedMergeFor(algebra) {
   return (stored, incoming) => {
@@ -1673,6 +2115,17 @@ function runRules(db, rules, algebra, given) {
   };
   const mergeStored = algebra === void 0 ? void 0 : storedMergeFor(algebra);
   const marks = canResume(rules, state) ? state.marks : void 0;
+  const producible = /* @__PURE__ */ new Set();
+  const canProduce = (r) => {
+    if (producible.has(r)) {
+      return true;
+    }
+    if (!couldProduce(db, r)) {
+      return false;
+    }
+    producible.add(r);
+    return true;
+  };
   const runStratum = (stratum) => {
     let delta = /* @__PURE__ */ new Map();
     const record = (relation, tuple) => {
@@ -1715,7 +2168,7 @@ function runRules(db, rules, algebra, given) {
         return;
       }
       const startedAt2 = performance.now();
-      const before = db.size(r.head.relation);
+      const before = sizeOf(db, r.head.relation);
       const readBefore = budget.examined;
       deriveInto(r, seed, deltaIndex);
       chargeRule(
@@ -1723,14 +2176,14 @@ function runRules(db, rules, algebra, given) {
         r.head.relation,
         r.body.map(literalName),
         performance.now() - startedAt2,
-        db.size(r.head.relation) - before,
+        sizeOf(db, r.head.relation) - before,
         budget.examined - readBefore
       );
     };
     const applyDelta = (seed, derivedOnly) => {
       for (const at of rulesReading(stratum, seed, derivedOnly)) {
         const r = stratum.rules[at];
-        if (!couldProduce(db, r)) {
+        if (!canProduce(r)) {
           continue;
         }
         const positives = positivesOf(r);
@@ -1748,13 +2201,13 @@ function runRules(db, rules, algebra, given) {
     };
     if (marks === void 0 || marks === null) {
       for (const r of stratum.rules) {
-        if (!couldProduce(db, r)) {
+        if (!canProduce(r)) {
           continue;
         }
         const all = /* @__PURE__ */ new Map();
         for (const l of r.body) {
           if (!l.negated) {
-            all.set(l.relation, db.facts(l.relation));
+            all.set(l.relation, tuplesOf(db, l.relation));
           }
         }
         runOneRule(r, all, -1);
@@ -1791,7 +2244,7 @@ function runRules(db, rules, algebra, given) {
   state.marks = currentMarks(db);
   if (isProfiling()) {
     chargeRelationSizes(
-      db.relationNames().map((name) => [name, db.size(name)]),
+      db.relationNames().map((name) => [name, sizeOf(db, name)]),
       derivedRelations
     );
   }
@@ -1827,6 +2280,7 @@ export {
   formatProfile,
   lit,
   notLit,
+  noteReads,
   profileEvaluation,
   profileEvaluationAsync,
   proofOf,