@suss/datalog 0.33.1 → 0.34.0

package/dist/index.js

@@ -257,7 +257,7 @@ function boundFirst(r, headAdornment, labels) {
     }
   });
   const boundColumns = (literal) => literal.terms.filter(
-    (term, column) => !labels.get(literal.relation)?.has(column) && (term.type === "constant" || bound.has(term.name))
+    (term, column) => !labels.get(literal.relation)?.has(column) && term.type === "variable" && bound.has(term.name)
   ).length;
   const remaining = [...r.body];
   const body = [];
@@ -354,6 +354,11 @@ function chargeEvaluationRows(examined) {
     }
   }
 }
+function chargeEngine(part, ms) {
+  for (const collector of open) {
+    collector.engineMs[part] += ms;
+  }
+}
 function chargeRound(ruleSet) {
   for (const collector of open) {
     collector.rounds += 1;
@@ -410,6 +415,7 @@ function openScope() {
     startedAt: performance.now(),
     rounds: 0,
     evaluations: 0,
+    engineMs: { evaluate: 0, clear: 0 },
     rules: /* @__PURE__ */ new Map(),
     relations: /* @__PURE__ */ new Map(),
     derivedRelations: /* @__PURE__ */ new Set(),
@@ -446,6 +452,7 @@ function summarise(mine) {
   return {
     wallMs: performance.now() - mine.startedAt,
     datalogMs: totalMs(mine.rules.values()),
+    engineMs: { ...mine.engineMs },
     rounds: mine.rounds,
     evaluations: mine.evaluations,
     examined: totalExamined(mine.rules.values()),
@@ -481,6 +488,9 @@ function formatProfile(profile) {
   lines.push(
     `datalog: ${profile.datalogMs.toFixed(0)}ms (${share(profile.datalogMs, profile.wallMs).trim()} of ${profile.wallMs.toFixed(0)}ms wall), ${profile.evaluations} evaluations, ${profile.rounds} rounds, ${profile.examined} rows read (${profile.largestEvaluation} in the biggest evaluation)`
   );
+  lines.push(
+    `  engine: ${profile.engineMs.evaluate.toFixed(0)}ms inside evaluate (${profile.datalogMs.toFixed(0)}ms of it in rules), ${profile.engineMs.clear.toFixed(0)}ms clearing relations between questions`
+  );
   const { asked, abandoned, skipped } = profile.questions;
   if (asked > 0) {
     lines.push(
@@ -513,6 +523,102 @@ function formatProfile(profile) {
 }
 
 // src/relation.ts
+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);
+  const buckets = relation.columns[column];
+  if (buckets === void 0) {
+    return null;
+  }
+  const stored = facts.map(
+    (fact) => 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) {
+    return;
+  }
+  bucket.splice(at, 1);
+  if (bucket.length === 0) {
+    buckets.delete(key);
+  }
+}
+function removeTuples(relation, stored) {
+  const leaving = new Set(stored);
+  relation.tuples = relation.tuples.filter((tuple) => !leaving.has(tuple));
+  for (const tuple of stored) {
+    relation.columns.forEach((buckets, column) => {
+      if (buckets !== void 0) {
+        removeFrom(buckets, tuple[column], tuple);
+      }
+    });
+    for (const index of relation.combined.values()) {
+      let level = index.root;
+      const last = index.columns.length - 1;
+      for (let at = 0; at < last && level !== void 0; at++) {
+        level = level.get(tuple[index.columns[at]]);
+      }
+      if (level !== void 0) {
+        removeFrom(
+          level,
+          tuple[index.columns[last]],
+          tuple
+        );
+      }
+    }
+  }
+}
+function columnsIn(mask) {
+  const columns = [];
+  for (let column = 0; mask >> column !== 0; column++) {
+    if (mask & 1 << column) {
+      columns.push(column);
+    }
+  }
+  return columns;
+}
+function addToCombined(index, tuple) {
+  const last = index.columns.length - 1;
+  if (index.columns[last] >= tuple.length) {
+    return;
+  }
+  let level = index.root;
+  for (let at = 0; at < last; at++) {
+    const value = tuple[index.columns[at]];
+    let next = level.get(value);
+    if (next === void 0) {
+      next = /* @__PURE__ */ new Map();
+      level.set(value, next);
+    }
+    level = next;
+  }
+  addToBucket(
+    level,
+    tuple[index.columns[last]],
+    tuple
+  );
+}
+function combinedBucketIn(relation, mask, values) {
+  let index = relation.combined.get(mask);
+  if (index === void 0) {
+    index = { columns: columnsIn(mask), root: /* @__PURE__ */ new Map() };
+    for (const tuple of relation.tuples) {
+      addToCombined(index, tuple);
+    }
+    relation.combined.set(mask, index);
+  }
+  let level = index.root;
+  for (const value of values) {
+    level = level.get(value);
+    if (level === void 0) {
+      return [];
+    }
+  }
+  return level;
+}
 function addToBucket(buckets, key, tuple) {
   const bucket = buckets.get(key);
   if (bucket === void 0) {
@@ -536,6 +642,72 @@ function bucketIn(relation, column, value) {
   return buckets.get(value) ?? [];
 }
 
+// src/stratum.ts
+function planStratum(rules) {
+  const derived = /* @__PURE__ */ new Set();
+  const readers = /* @__PURE__ */ new Map();
+  for (let at = 0; at < rules.length; at++) {
+    const r = rules[at];
+    derived.add(r.head.relation);
+    for (const literal of r.body) {
+      if (literal.negated) {
+        continue;
+      }
+      const positions = readers.get(literal.relation);
+      if (positions === void 0) {
+        readers.set(literal.relation, [at]);
+        continue;
+      }
+      if (positions[positions.length - 1] !== at) {
+        positions.push(at);
+      }
+    }
+  }
+  return { rules, derived, readers, marked: new Uint8Array(rules.length) };
+}
+var NONE = [];
+function rulesReading(stratum, seed, derivedOnly) {
+  const lists = [];
+  for (const [relation, tuples] of seed) {
+    if (tuples.length === 0) {
+      continue;
+    }
+    if (derivedOnly && !stratum.derived.has(relation)) {
+      continue;
+    }
+    const positions = stratum.readers.get(relation);
+    if (positions !== void 0) {
+      lists.push(positions);
+    }
+  }
+  if (lists.length === 0) {
+    return NONE;
+  }
+  if (lists.length === 1) {
+    return lists[0];
+  }
+  return unionInOrder(lists, stratum.marked);
+}
+function unionInOrder(lists, marked) {
+  let first = marked.length;
+  let last = -1;
+  for (const positions of lists) {
+    for (const at of positions) {
+      marked[at] = 1;
+    }
+    first = Math.min(first, positions[0]);
+    last = Math.max(last, positions[positions.length - 1]);
+  }
+  const union = [];
+  for (let at = first; at <= last; at++) {
+    if (marked[at] === 1) {
+      marked[at] = 0;
+      union.push(at);
+    }
+  }
+  return union;
+}
+
 // src/confidence.ts
 var RANK = {
   low: 0,
@@ -614,9 +786,7 @@ var Witness = class {
 var witnesses = {
   asserted: "asserted",
   absent: "absent",
-  // A witness is built from the derivation alone, and saying so lets
-  // the evaluator skip the body-tag lookups, which were most of the
-  // tagged path's cost on a large sweep.
+  // A witness is built from the derivation alone.
   ignoresBodyTags: true,
   combine: (_bodyTags, derivation) => new Witness(derivation.rule, derivation.body),
   merge: (stored) => stored
@@ -678,6 +848,7 @@ var notLit = (relation, ...terms) => ({
 var rule = (relation, terms, body, name) => name === void 0 ? { head: { relation, terms }, body } : { head: { relation, terms }, body, name };
 var literalName = (literal) => literal.negated ? `!${literal.relation}` : literal.relation;
 var ruleLabel = (r) => r.name ?? `${r.head.relation} :- ${r.body.map(literalName).join(", ")}`;
+var FEW_REMOVED = 16;
 var Database = class {
   store = /* @__PURE__ */ new Map();
   relation(name) {
@@ -688,15 +859,16 @@ var Database = class {
     const created = {
       index: new FactIndex(),
       tuples: [],
-      columns: []
+      columns: [],
+      combined: /* @__PURE__ */ new Map()
     };
     this.store.set(name, created);
     return created;
   }
   /**
    * The key this relation gives a tuple, whether or not the fact is
-   * present. Evaluation keys its ledger of derived facts by it; a
-   * caller outside this module has nowhere to spend one.
+   * present. Evaluation keys its ledger of derived facts by it. Nothing
+   * outside this module accepts a key.
    */
   keyFor(relationName, tuple) {
     return this.relation(relationName).index.key(tuple);
@@ -736,6 +908,9 @@ var Database = class {
         addToBucket(buckets, value, tuple);
       }
     }
+    for (const combined of relation.combined.values()) {
+      addToCombined(combined, tuple);
+    }
     return "added";
   }
   /** The tag stored for this fact, or undefined when there is none. */
@@ -801,18 +976,45 @@ var Database = class {
     if (index.size === 0) {
       relation.tuples = [];
       index.clear();
+      relation.columns.length = 0;
+      relation.combined.clear();
+      forgetFacts(this, relationName, going);
+      return going.size;
+    }
+    for (const tuple of gone) {
+      index.prune(tuple);
+    }
+    const stored = gone.length * FEW_REMOVED < relation.tuples.length ? storedTuplesOf(relation, gone) : null;
+    if (stored !== null) {
+      removeTuples(relation, stored);
     } else {
       relation.tuples = relation.tuples.filter(
         (tuple) => index.find(tuple) !== void 0
       );
-      for (const tuple of gone) {
-        index.prune(tuple);
-      }
+      relation.columns.length = 0;
+      relation.combined.clear();
     }
-    relation.columns.length = 0;
     forgetFacts(this, relationName, going);
     return going.size;
   }
+  /**
+   * Remove every fact in a relation, and return how many there were. The
+   * database ends up as `retract` leaves it when handed every tuple, but
+   * nothing looks a tuple up to remove it.
+   */
+  retractAll(relationName) {
+    const relation = this.store.get(relationName);
+    if (relation === void 0 || relation.tuples.length === 0) {
+      return 0;
+    }
+    const removed = relation.tuples.length;
+    relation.tuples = [];
+    relation.index.clear();
+    relation.columns.length = 0;
+    relation.combined.clear();
+    forgetRelation(this, relationName);
+    return removed;
+  }
   size(relationName) {
     return this.store.get(relationName)?.tuples.length ?? 0;
   }
@@ -820,6 +1022,25 @@ var Database = class {
     return [...this.store.keys()];
   }
 };
+function rulesDeriving(rules, relations) {
+  const wanted = new Set(relations);
+  const pending = [...relations];
+  while (pending.length > 0) {
+    const relation = pending.pop();
+    for (const r of rules) {
+      if (r.head.relation !== relation) {
+        continue;
+      }
+      for (const literal of r.body) {
+        if (!wanted.has(literal.relation)) {
+          wanted.add(literal.relation);
+          pending.push(literal.relation);
+        }
+      }
+    }
+  }
+  return rules.filter((r) => wanted.has(r.head.relation));
+}
 function stratify(rules) {
   const derived = new Set(rules.map((r) => r.head.relation));
   const stratum = /* @__PURE__ */ new Map();
@@ -919,13 +1140,16 @@ function headTuple(head, bindings) {
   });
 }
 var positiveLiterals = /* @__PURE__ */ new WeakMap();
-function deltaLiteral(r, deltaIndex) {
+function positivesOf(r) {
   let positives = positiveLiterals.get(r);
   if (positives === void 0) {
     positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
     positiveLiterals.set(r, positives);
   }
-  return positives[deltaIndex] ?? -1;
+  return positives;
+}
+function deltaLiteral(r, deltaIndex) {
+  return positivesOf(r)[deltaIndex] ?? -1;
 }
 var allBound = (literal, bindings) => literal.terms.every(
   (term) => term.type === "constant" || boundValue(bindings, term.name) !== void 0
@@ -968,58 +1192,139 @@ function evaluateRule(db, deltas, r, deltaIndex, budget) {
       results.push(headTuple(r.head, bindings));
       return;
     }
-    let pick = -1;
-    let narrowest = null;
-    for (let index = 0; index < body.length; index++) {
-      if (taken & 1 << index) {
-        continue;
-      }
-      const literal = body[index];
-      if (literal.negated) {
-        if (allBound(literal, bindings)) {
-          if (!db.has(literal.relation, groundNegated(literal, bindings))) {
-            step(taken | 1 << index, bindings);
-          }
-          return;
-        }
-        continue;
-      }
-      const source = narrowedSource(db, literal, bindings);
-      if (source === null) {
-        continue;
-      }
-      if (source.length === 0) {
-        return;
-      }
-      if (narrowest === null || source.length < narrowest.length) {
-        pick = index;
-        narrowest = source;
-      }
-    }
-    if (narrowest !== null) {
-      walk2(pick, narrowest, taken, bindings);
+    const index = nextLiteral(db, body, taken, bindings);
+    if (index === -1) {
       return;
     }
-    for (let index = 0; index < body.length; index++) {
-      if (!(taken & 1 << index) && !body[index].negated) {
-        walk2(index, db.facts(body[index].relation), taken, bindings);
-        return;
-      }
-    }
-    for (let index = 0; index < body.length; index++) {
-      if (!(taken & 1 << index)) {
-        groundNegated(body[index], bindings);
+    const literal = body[index];
+    if (literal.negated) {
+      if (!db.has(literal.relation, groundNegated(literal, bindings))) {
+        step(taken | 1 << index, bindings);
       }
+      return;
     }
+    walk2(index, nextSource, taken, bindings);
   };
   if (deltaAt === -1) {
     step(0, null);
-  } else {
-    walk2(deltaAt, deltas.get(body[deltaAt].relation) ?? [], 0, null);
+    return results;
+  }
+  const rows = deltaRows(deltas, body[deltaAt], budget);
+  const start = smallerStart(db, body, deltaAt, rows);
+  if (start === null) {
+    walk2(deltaAt, rows, 0, null);
+    return results;
+  }
+  const byValue = newFactsByColumn(rows, start.column, budget);
+  const first = body[start.index];
+  for (const tuple of start.source) {
+    budget.examined++;
+    if (budget.examined > budget.limit) {
+      throw OUT_OF_BUDGET;
+    }
+    const bindings = unify(first, tuple, null);
+    if (bindings === NO_MATCH) {
+      continue;
+    }
+    const value = boundValue(bindings, start.variable);
+    const matching = value === void 0 ? void 0 : byValue.get(value);
+    if (matching !== void 0) {
+      walk2(deltaAt, matching, 1 << start.index, bindings);
+    }
   }
   return results;
 }
-var boundSource = (db, literal, bindings) => narrowedSource(db, literal, bindings) ?? db.facts(literal.relation);
+var newFactIndexes = /* @__PURE__ */ new WeakMap();
+function smallerStart(db, body, deltaAt, rows) {
+  const newFacts = body[deltaAt];
+  const indexed = newFactIndexes.get(rows);
+  let best = null;
+  for (let index = 0; index < body.length; index++) {
+    const literal = body[index];
+    if (index === deltaAt || literal.negated) {
+      continue;
+    }
+    const column = sharedColumn(newFacts, literal);
+    if (column === -1) {
+      continue;
+    }
+    const source = narrowedSource(db, literal, null) ?? db.facts(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 = {
+        index,
+        source,
+        variable: newFacts.terms[column].name,
+        column
+      };
+    }
+  }
+  return best;
+}
+function sharedColumn(from, other) {
+  return from.terms.findIndex(
+    (term) => term.type === "variable" && other.terms.some((t) => t.type === "variable" && t.name === term.name)
+  );
+}
+function newFactsByColumn(rows, column, budget) {
+  let byColumn = newFactIndexes.get(rows);
+  if (byColumn === void 0) {
+    byColumn = /* @__PURE__ */ new Map();
+    newFactIndexes.set(rows, byColumn);
+  }
+  let byValue = byColumn.get(column);
+  if (byValue === void 0) {
+    byValue = /* @__PURE__ */ new Map();
+    for (const tuple of rows) {
+      const value = tuple[column];
+      if (value !== void 0) {
+        addToBucket(byValue, value, tuple);
+      }
+    }
+    budget.examined += rows.length;
+    byColumn.set(column, byValue);
+  }
+  return byValue;
+}
+var nextSource = [];
+function nextLiteral(db, body, taken, bindings) {
+  let pick = -1;
+  let narrowest = null;
+  for (let index = 0; index < body.length; index++) {
+    if (taken & 1 << index) {
+      continue;
+    }
+    const literal = body[index];
+    if (literal.negated) {
+      if (allBound(literal, bindings)) {
+        return index;
+      }
+      continue;
+    }
+    const source = narrowedSource(db, literal, bindings);
+    if (source === null) {
+      continue;
+    }
+    if (source.length === 0) {
+      return -1;
+    }
+    if (narrowest === null || source.length < narrowest.length) {
+      pick = index;
+      narrowest = source;
+    }
+  }
+  if (narrowest !== null) {
+    nextSource = narrowedFurther(db, body[pick], bindings, narrowest);
+    return nextSource.length === 0 ? -1 : pick;
+  }
+  for (let index = 0; index < body.length; index++) {
+    if (!(taken & 1 << index) && !body[index].negated) {
+      nextSource = db.facts(body[index].relation);
+      return index;
+    }
+  }
+  return body.findIndex((_, index) => !(taken & 1 << index));
+}
 function narrowedSource(db, literal, bindings) {
   const relation = db.relationOf(literal.relation);
   let narrowest = null;
@@ -1039,14 +1344,119 @@ function narrowedSource(db, literal, bindings) {
   }
   return narrowest;
 }
+function narrowedFurther(db, literal, bindings, source) {
+  if (source.length <= 1) {
+    return source;
+  }
+  let mask = 0;
+  const values = [];
+  for (let column = 0; column < literal.terms.length && column < 31; column++) {
+    const term = literal.terms[column];
+    const value = term.type === "constant" ? term.value : boundValue(bindings, term.name);
+    if (value !== void 0) {
+      mask |= 1 << column;
+      values.push(value);
+    }
+  }
+  const relation = db.relationOf(literal.relation);
+  if (values.length < 2 || relation === void 0) {
+    return source;
+  }
+  return combinedBucketIn(relation, mask, values);
+}
+var constantColumns = /* @__PURE__ */ new WeakMap();
+function constantColumnsOf(literal) {
+  let known = constantColumns.get(literal);
+  if (known === void 0) {
+    const columns = [];
+    const values = [];
+    literal.terms.forEach((term, column) => {
+      if (term.type === "constant") {
+        columns.push(column);
+        values.push(term.value);
+      }
+    });
+    known = columns.length === 0 ? null : { columns, values };
+    constantColumns.set(literal, known);
+  }
+  return known;
+}
+var deltaBuckets = /* @__PURE__ */ new WeakMap();
+var deltaBucketKey = (relation, column) => `${relation}\0${column}`;
+function hasNoNewRows(deltas, literal) {
+  const rows = deltas.get(literal.relation) ?? [];
+  const constants = constantColumnsOf(literal);
+  if (rows.length === 0 || constants === null) {
+    return rows.length === 0;
+  }
+  const buckets = deltaBuckets.get(deltas)?.get(deltaBucketKey(literal.relation, constants.columns[0]));
+  return buckets !== void 0 && !buckets.has(constants.values[0]);
+}
+function deltaRows(deltas, literal, budget) {
+  const rows = deltas.get(literal.relation) ?? [];
+  const constants = constantColumnsOf(literal);
+  if (constants === null || rows.length <= 1) {
+    return rows;
+  }
+  let byColumn = deltaBuckets.get(deltas);
+  if (byColumn === void 0) {
+    byColumn = /* @__PURE__ */ new Map();
+    deltaBuckets.set(deltas, byColumn);
+  }
+  const column = constants.columns[0];
+  const key = deltaBucketKey(literal.relation, column);
+  let buckets = byColumn.get(key);
+  if (buckets === void 0) {
+    buckets = /* @__PURE__ */ new Map();
+    for (const tuple of rows) {
+      const value = tuple[column];
+      if (value !== void 0) {
+        addToBucket(buckets, value, tuple);
+      }
+    }
+    budget.examined += rows.length;
+    byColumn.set(key, buckets);
+  }
+  const bucket = buckets.get(constants.values[0]) ?? [];
+  if (constants.columns.length === 1) {
+    return bucket;
+  }
+  return bucket.filter(
+    (tuple) => constants.columns.every(
+      (at, i) => at === column || tuple[at] === constants.values[i]
+    )
+  );
+}
 var EMPTY_TAGS = [];
 function evaluateRuleTagged(db, deltas, r, deltaIndex, algebra, budget) {
   const results = [];
-  const bodyTags = [];
-  const bodyMatches = [];
+  const body = r.body;
+  const deltaAt = deltaLiteral(r, deltaIndex);
+  const whole = 2 ** body.length - 1;
+  const bodyTags = new Array(body.length);
+  const bodyMatches = new Array(body.length);
   const readsTags = algebra.ignoresBodyTags !== true;
-  const step = (literalIndex, positiveIndex, bindings) => {
-    if (literalIndex === r.body.length) {
+  const walk2 = (index, source, taken, bindings) => {
+    const literal = body[index];
+    for (const tuple of source) {
+      budget.examined++;
+      const next = unify(literal, tuple, bindings);
+      if (next !== NO_MATCH) {
+        if (readsTags) {
+          const stored = db.tagOf(literal.relation, tuple);
+          bodyTags[index] = stored === void 0 ? algebra.asserted : stored;
+        }
+        bodyMatches[index] = {
+          kind: "fact",
+          relation: literal.relation,
+          tuple
+        };
+        step(taken | 1 << index, next);
+      }
+    }
+  };
+  const step = (taken, bindings) => {
+    if (taken === whole) {
       results.push({
         tuple: headTuple(r.head, bindings),
         tag: algebra.combine(readsTags ? bodyTags.slice() : EMPTY_TAGS, {
@@ -1056,51 +1466,33 @@ function evaluateRuleTagged(db, deltas, r, deltaIndex, algebra, budget) {
       });
       return;
     }
-    const literal = r.body[literalIndex];
+    const index = nextLiteral(db, body, taken, bindings);
+    if (index === -1) {
+      return;
+    }
+    const literal = body[index];
     if (literal.negated) {
       const grounded = groundNegated(literal, bindings);
       if (!db.has(literal.relation, grounded)) {
         if (readsTags) {
-          bodyTags.push(algebra.absent);
+          bodyTags[index] = algebra.absent;
         }
-        bodyMatches.push({
+        bodyMatches[index] = {
           kind: "absence",
           relation: literal.relation,
           tuple: grounded
-        });
-        step(literalIndex + 1, positiveIndex, bindings);
-        if (readsTags) {
-          bodyTags.pop();
-        }
-        bodyMatches.pop();
+        };
+        step(taken | 1 << index, bindings);
       }
       return;
     }
-    const source = positiveIndex === deltaIndex ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
-    for (const tuple of source) {
-      budget.examined++;
-      const next = unify(literal, tuple, bindings);
-      if (next !== NO_MATCH) {
-        if (readsTags) {
-          const stored = db.tagOf(literal.relation, tuple);
-          bodyTags.push(
-            stored === void 0 ? algebra.asserted : stored
-          );
-        }
-        bodyMatches.push({
-          kind: "fact",
-          relation: literal.relation,
-          tuple
-        });
-        step(literalIndex + 1, positiveIndex + 1, next);
-        if (readsTags) {
-          bodyTags.pop();
-        }
-        bodyMatches.pop();
-      }
-    }
+    walk2(index, nextSource, taken, bindings);
   };
-  step(0, 0, null);
+  if (deltaAt === -1) {
+    step(0, null);
+  } else {
+    walk2(deltaAt, deltaRows(deltas, body[deltaAt], budget), 0, null);
+  }
   return results;
 }
 var evaluated = /* @__PURE__ */ new WeakMap();
@@ -1140,6 +1532,16 @@ function forgetFacts(db, relation, keys) {
     }
   }
 }
+function forgetRelation(db, relation) {
+  const states = evaluated.get(db);
+  if (states === void 0) {
+    return;
+  }
+  for (const state of states.values()) {
+    state.marks = null;
+    state.derived.get(relation)?.clear();
+  }
+}
 var usesNegation = (rules) => rules.some((r) => r.body.some((l) => l.negated));
 function canResume(rules, state) {
   return !usesNegation(rules) && state.marks !== null;
@@ -1172,6 +1574,8 @@ function evaluate(db, rules, algebra, budget) {
     throw new Error("cannot evaluate with both a tag algebra and a row budget");
   }
   deriving.set(db, (deriving.get(db) ?? 0) + 1);
+  const profiling = isProfiling();
+  const startedAt = profiling ? performance.now() : 0;
   try {
     return runRules(db, rules, algebra, budget);
   } finally {
@@ -1181,16 +1585,24 @@ function evaluate(db, rules, algebra, budget) {
     } else {
       deriving.set(db, depth);
     }
+    if (profiling) {
+      chargeEngine("evaluate", performance.now() - startedAt);
+    }
   }
 }
 function clearRelations(db, rules, relations) {
+  const profiling = isProfiling();
+  const startedAt = profiling ? performance.now() : 0;
   for (const relation of relations) {
-    db.retract(relation, [...db.facts(relation)]);
+    db.retractAll(relation);
   }
   const state = statesFor(db).get(signatureOf(rules));
   if (state !== void 0) {
     state.marks = currentMarks(db);
   }
+  if (profiling) {
+    chargeEngine("clear", performance.now() - startedAt);
+  }
 }
 var signatureOf = (rules) => shapeOf(rules).signature;
 var shapes = /* @__PURE__ */ new WeakMap();
@@ -1204,7 +1616,7 @@ function shapeOf(rules) {
     signature: JSON.stringify(rules),
     name: [...derivedRelations].sort().join(", "),
     derivedRelations,
-    strata: stratify(rules)
+    strata: stratify(rules).map(planStratum)
   };
   shapes.set(rules, shape);
   return shape;
@@ -1263,7 +1675,6 @@ function runRules(db, rules, algebra, given) {
   const marks = canResume(rules, state) ? state.marks : void 0;
   const runStratum = (stratum) => {
     let delta = /* @__PURE__ */ new Map();
-    const derivedHere = new Set(stratum.map((r) => r.head.relation));
     const record = (relation, tuple) => {
       if (db.add(relation, tuple) === "added") {
         addTo(delta, relation, tuple);
@@ -1317,17 +1728,18 @@ function runRules(db, rules, algebra, given) {
       );
     };
     const applyDelta = (seed, derivedOnly) => {
-      for (const r of stratum) {
+      for (const at of rulesReading(stratum, seed, derivedOnly)) {
+        const r = stratum.rules[at];
         if (!couldProduce(db, r)) {
           continue;
         }
-        const positives = r.body.filter((l) => !l.negated);
+        const positives = positivesOf(r);
         for (let i = 0; i < positives.length; i++) {
-          const literal = positives[i];
-          if (derivedOnly && !derivedHere.has(literal.relation)) {
+          const literal = r.body[positives[i]];
+          if (derivedOnly && !stratum.derived.has(literal.relation)) {
             continue;
           }
-          if ((seed.get(literal.relation) ?? []).length === 0) {
+          if (hasNoNewRows(seed, literal)) {
             continue;
           }
           runOneRule(r, seed, i);
@@ -1335,7 +1747,7 @@ function runRules(db, rules, algebra, given) {
       }
     };
     if (marks === void 0 || marks === null) {
-      for (const r of stratum) {
+      for (const r of stratum.rules) {
         if (!couldProduce(db, r)) {
           continue;
         }
@@ -1421,6 +1833,7 @@ export {
   rowBudget,
   rule,
   ruleLabel,
+  rulesDeriving,
   stratify,
   tupleKey,
   tupleKeyParts,