@suss/datalog 0.21.0 → 0.22.0

package/README.md

@@ -64,6 +64,24 @@ column gets indexed the first time something asks for it and stays up to
 date after that, so a relation nobody joins on that way never gets an
 index at all.
 
+The body is not always walked in the order it was written. A round draws
+one literal from the facts that arrived last round, and that list is
+usually short, so it goes first and everything after it starts with some
+variables already bound. Take `chain(x, z) :- chain(x, y), binds(y, z)`
+in the round where new `binds` facts arrive. Written order asks for
+`chain(x, y)` with nothing bound, which scans every chain fact and tries
+each one against every new binding. Leading with the new bindings binds
+`y`, and `chain` then comes off its index on that column. On suss's own
+sources that one reordering took the rule from 2.4 seconds to 55
+milliseconds.
+
+Once the delta leads, the rest of the body follows greedily: the next
+literal is one sharing a variable that is already bound, so it too comes
+off an index rather than scanning. A negated literal is a filter, so it
+is placed as soon as its variables are bound. A join produces the same
+rows whatever order it walks in, so this changes what a round costs and
+not what it derives.
+
 `evaluate` picks up where it left off. Call it again with the same rules
 after adding facts and it starts from the facts you added rather than
 redoing the whole fixpoint. Callers that go back and forth between
@@ -243,6 +261,19 @@ companion becomes a literal in the rule body, and demand travels down
 each body the same way the join binds variables. A relation nothing asks
 for is not derived at all, so only read back the relations you listed.
 
+The rewrite puts each body in the order demand should travel, which is
+not always written order. At each position it takes the literal with the
+most columns already fixed, by a constant or by a variable the head or
+an earlier literal bound, and keeps written order between equals. Take
+`moduleExport(m, n, v) <- reExports(m, n, m2, n2), moduleExport(m2, n2,
+v)` asked with `v` bound. In written order the re-export comes first and
+binds `m2` and `n2` off every re-export in the program, so the recursive
+call wants `moduleExport` with all three columns bound: one demand fact
+per re-export per value asked about. With `moduleExport(m2, n2, v)`
+first, the demand stays on `v` and the re-exports come off an index on
+`m2`. A body the head binds nothing in starts with its written first
+literal.
+
 This costs you two things. The companion relations are stored like any
 other, at a few tuples per value asked about, so a caller who asks about
 most of a program ends up deriving more rather than less. And the
@@ -282,6 +313,24 @@ Keep the facts you add and the facts the rules derive in separate
 relations. Taking a conclusion back cannot tell one from the other, and
 splitting them is how people normally write Datalog anyway.
 
+### Reading what the rules are waiting on
+
+Demand is also something a caller can read. `program.demands` lists
+each demand relation with the relation it is for and which of that
+relation's columns a demand row fixes, in column order:
+
+```ts
+program.demands;
+// [{ relation: "reaches", bound: [true, false], demand: "wanted:reaches" }]
+db.facts("wanted:reaches"); // [["a"], ["b"], ["c"]]
+```
+
+A caller that loads its base facts lazily uses this to find out what to
+load next. Evaluate, read the demand rows on the relation whose base
+facts come from somewhere else, fetch those, evaluate again, and stop
+when no demand row is new. The rules then decide what gets loaded, and
+the caller never has to guess how far a chain runs.
+
 Extraction-scale fact sets run to thousands of tuples. If that changes,
 the rule data model is the part that stays and this evaluator is the
 part you replace.

package/dist/index.cjs

@@ -93,7 +93,8 @@ function deriveOnDemand(rules, complete) {
   }
   while (pending.length > 0) {
     const adorned = pending.pop();
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -116,6 +117,7 @@ function deriveOnDemand(rules, complete) {
   const demandOn = (relation, adornment) => `wanted:${nameOf(relation, adornment)}`;
   const rewritten = [];
   const demandDriven = /* @__PURE__ */ new Set();
+  const demands = [];
   const already = /* @__PURE__ */ new Set();
   const emit = (r) => {
     const key = JSON.stringify(r);
@@ -128,8 +130,14 @@ function deriveOnDemand(rules, complete) {
     if (anyBound(adorned.adornment)) {
       demandDriven.add(nameOf(adorned.relation, adorned.adornment));
       demandDriven.add(demandOn(adorned.relation, adorned.adornment));
+      demands.push({
+        relation: adorned.relation,
+        bound: adorned.adornment,
+        demand: demandOn(adorned.relation, adorned.adornment)
+      });
     }
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -141,13 +149,14 @@ function deriveOnDemand(rules, complete) {
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
         if (adornment !== null && anyBound(adornment)) {
-          emit({
-            head: {
-              relation: demandOn(literal.relation, adornment),
-              terms: boundTerms(literal.terms, adornment)
-            },
-            body: [...guard, ...body]
-          });
+          const demand = positiveLiteral(
+            demandOn(literal.relation, adornment),
+            boundTerms(literal.terms, adornment)
+          );
+          const premises = [...guard, ...body];
+          if (!sameLiteral(premises, demand)) {
+            emit({ head: demand, body: premises });
+          }
         }
         body.push(
           adornment === null ? literal : positiveLiteral(
@@ -166,7 +175,37 @@ function deriveOnDemand(rules, complete) {
     }
   }
   demandRewrites.add(rewritten);
-  return { rules: rewritten, demandDriven: [...demandDriven] };
+  return { rules: rewritten, demandDriven: [...demandDriven], demands };
+}
+var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
+function boundFirst(r, headAdornment) {
+  const bound = /* @__PURE__ */ new Set();
+  r.head.terms.forEach((term, column) => {
+    if (headAdornment[column] && term.type === "variable") {
+      bound.add(term.name);
+    }
+  });
+  const boundColumns = (literal) => literal.terms.filter(
+    (term) => term.type === "constant" || bound.has(term.name)
+  ).length;
+  const remaining = [...r.body];
+  const body = [];
+  while (remaining.length > 0) {
+    let pick = 0;
+    for (let at = 1; at < remaining.length; at++) {
+      if (boundColumns(remaining[at]) > boundColumns(remaining[pick])) {
+        pick = at;
+      }
+    }
+    const [literal] = remaining.splice(pick, 1);
+    body.push(literal);
+    for (const term of literal.terms) {
+      if (term.type === "variable") {
+        bound.add(term.name);
+      }
+    }
+  }
+  return { head: r.head, body };
 }
 function bodyAdornments(r, headAdornment, derives) {
   const bound = /* @__PURE__ */ new Set();
@@ -349,7 +388,13 @@ function formatProfile(profile) {
 
 // src/tupleKey.ts
 var atomKey = (a) => typeof a === "number" ? `n${a}:` : `s${a.length}:${a}`;
-var tupleKey = (parts) => parts.map(atomKey).join("");
+var tupleKey = (parts) => {
+  let key = "";
+  for (let i = 0; i < parts.length; i++) {
+    key += atomKey(parts[i]);
+  }
+  return key;
+};
 function tupleKeyParts(key) {
   const parts = [];
   let at = 0;
@@ -483,7 +528,16 @@ 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 keyOf2 = (tuple) => tupleKey(tuple);
+var keys = /* @__PURE__ */ new WeakMap();
+var keyOf2 = (tuple) => {
+  const known = keys.get(tuple);
+  if (known !== void 0) {
+    return known;
+  }
+  const key = tupleKey(tuple);
+  keys.set(tuple, key);
+  return key;
+};
 function tagSlots(relation) {
   if (relation.tags === void 0) {
     relation.tags = /* @__PURE__ */ new Map();
@@ -615,9 +669,7 @@ var Database = class {
       relation.keys.delete(key);
       relation.tags?.delete(key);
     }
-    relation.tuples = relation.tuples.filter(
-      (tuple) => !going.has(keyOf2(tuple))
-    );
+    relation.tuples = relation.keys.size === 0 ? [] : relation.tuples.filter((tuple) => !going.has(keyOf2(tuple)));
     relation.indexes.clear();
     forgetFacts(this, relationName, going);
     return going.size;
@@ -727,29 +779,90 @@ function headTuple(head, bindings) {
     return bound;
   });
 }
+var variablesOf = (literal) => literal.terms.filter((term) => term.type === "variable").map((term) => term.name);
+var plans = /* @__PURE__ */ new WeakMap();
+function bodyPlan(r, deltaIndex) {
+  let byDelta = plans.get(r);
+  if (byDelta === void 0) {
+    byDelta = /* @__PURE__ */ new Map();
+    plans.set(r, byDelta);
+  }
+  const known = byDelta.get(deltaIndex);
+  if (known !== void 0) {
+    return known;
+  }
+  const positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+  const deltaAt = positives[deltaIndex] ?? -1;
+  const computed = { deltaAt, order: planBodyOrder(r, deltaAt) };
+  byDelta.set(deltaIndex, computed);
+  return computed;
+}
+function planBodyOrder(r, deltaAt) {
+  const natural = r.body.map((_, i) => i);
+  if (deltaAt <= 0) {
+    return natural;
+  }
+  const taken = r.body.map(() => false);
+  const bound = /* @__PURE__ */ new Set();
+  const order = [];
+  const take = (index) => {
+    taken[index] = true;
+    order.push(index);
+    for (const name of variablesOf(r.body[index])) {
+      bound.add(name);
+    }
+  };
+  const firstWhere = (want) => natural.find((index) => !taken[index] && want(index)) ?? -1;
+  const nextLiteral = () => {
+    const ready = firstWhere(
+      (i) => r.body[i].negated && variablesOf(r.body[i]).every((name) => bound.has(name))
+    );
+    if (ready !== -1) {
+      return ready;
+    }
+    const joined = firstWhere(
+      (i) => !r.body[i].negated && variablesOf(r.body[i]).some((name) => bound.has(name))
+    );
+    if (joined !== -1) {
+      return joined;
+    }
+    const disconnected = firstWhere((i) => !r.body[i].negated);
+    if (disconnected !== -1) {
+      return disconnected;
+    }
+    return firstWhere(() => true);
+  };
+  take(deltaAt);
+  while (order.length < r.body.length) {
+    take(nextLiteral());
+  }
+  return order;
+}
 function evaluateRule(db, deltas, r, deltaIndex) {
   const results = [];
-  const step = (literalIndex, positiveIndex, bindings) => {
-    if (literalIndex === r.body.length) {
+  const { deltaAt, order } = bodyPlan(r, deltaIndex);
+  const step = (orderIndex, bindings) => {
+    if (orderIndex === order.length) {
       results.push(headTuple(r.head, bindings));
       return;
     }
+    const literalIndex = order[orderIndex];
     const literal = r.body[literalIndex];
     if (literal.negated) {
       if (!db.has(literal.relation, groundNegated(literal, bindings))) {
-        step(literalIndex + 1, positiveIndex, bindings);
+        step(orderIndex + 1, bindings);
       }
       return;
     }
-    const source = positiveIndex === deltaIndex ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
     for (const tuple of source) {
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(literalIndex + 1, positiveIndex + 1, next);
+        step(orderIndex + 1, next);
       }
     }
   };
-  step(0, 0, null);
+  step(0, null);
   return results;
 }
 function boundSource(db, literal, bindings) {
@@ -855,7 +968,7 @@ function claimFact(db, relation, key) {
     state.derived.get(relation)?.delete(key);
   }
 }
-function forgetFacts(db, relation, keys) {
+function forgetFacts(db, relation, keys2) {
   const states = evaluated.get(db);
   if (states === void 0) {
     return;
@@ -864,7 +977,7 @@ function forgetFacts(db, relation, keys) {
     state.marks = null;
     const ledger = state.derived.get(relation);
     if (ledger !== void 0) {
-      for (const key of keys) {
+      for (const key of keys2) {
         ledger.delete(key);
       }
     }

package/dist/index.d.cts

@@ -31,6 +31,18 @@ declare function confidenceWith(levelOf: (rule: Rule) => ConfidenceLevel | undef
 /** The confidence algebra with every rule counted as exact. */
 declare const confidence: TagAlgebra<ConfidenceLevel>;
 
+/** One demand relation the rewrite created, and what its rows say. */
+interface Demand {
+    /** The relation whose rows are being waited on. */
+    relation: string;
+    /** Which columns of that relation a demand row fixes. */
+    bound: readonly boolean[];
+    /**
+     * The demand relation's name. Each of its rows lists the bound
+     * columns' values, in the relation's column order.
+     */
+    demand: string;
+}
 /** A rewritten rule set, and which of its relations demand restricts. */
 interface OnDemandRules {
     /** The rewritten rules, ready to evaluate. */
@@ -43,6 +55,13 @@ interface OnDemandRules {
      * answers.
      */
     demandDriven: string[];
+    /**
+     * The demand relations by what they ask for, so a caller can read
+     * what the rules are waiting on and go and get it: a store that
+     * loads facts lazily reads the demand on a module's exports and
+     * extracts that module.
+     */
+    demands: Demand[];
 }
 /**
  * Rewrite `rules` so the relations listed in `complete` still come out
@@ -419,4 +438,4 @@ declare function evaluate<Tag = never>(db: Database, rules: Rule[], algebra?: Ta
  */
 declare function clearRelations(db: Database, rules: Rule[], relations: readonly string[]): void;
 
-export { type AddOutcome, type Atom, type BodyMatch, type ConfidenceLevel, Database, type Derivation, type EvaluationProfile, type Literal, type OnDemandRules, type Proof, type ProofDerived, type ProofOptions, type Rule, type RuleCost, type TagAlgebra, type Term, type Tuple, Witness, type WitnessTag, clearRelations, confidence, confidenceWith, constant, deriveOnDemand, evaluate, formatProfile, lit, notLit, profileEvaluation, profileEvaluationAsync, proofOf, rule, ruleLabel, stratify, tupleKey, tupleKeyParts, variable, witnesses };
+export { type AddOutcome, type Atom, type BodyMatch, type ConfidenceLevel, Database, type Demand, type Derivation, type EvaluationProfile, type Literal, type OnDemandRules, type Proof, type ProofDerived, type ProofOptions, type Rule, type RuleCost, type TagAlgebra, type Term, type Tuple, Witness, type WitnessTag, clearRelations, confidence, confidenceWith, constant, deriveOnDemand, evaluate, formatProfile, lit, notLit, profileEvaluation, profileEvaluationAsync, proofOf, rule, ruleLabel, stratify, tupleKey, tupleKeyParts, variable, witnesses };

package/dist/index.d.ts

@@ -31,6 +31,18 @@ declare function confidenceWith(levelOf: (rule: Rule) => ConfidenceLevel | undef
 /** The confidence algebra with every rule counted as exact. */
 declare const confidence: TagAlgebra<ConfidenceLevel>;
 
+/** One demand relation the rewrite created, and what its rows say. */
+interface Demand {
+    /** The relation whose rows are being waited on. */
+    relation: string;
+    /** Which columns of that relation a demand row fixes. */
+    bound: readonly boolean[];
+    /**
+     * The demand relation's name. Each of its rows lists the bound
+     * columns' values, in the relation's column order.
+     */
+    demand: string;
+}
 /** A rewritten rule set, and which of its relations demand restricts. */
 interface OnDemandRules {
     /** The rewritten rules, ready to evaluate. */
@@ -43,6 +55,13 @@ interface OnDemandRules {
      * answers.
      */
     demandDriven: string[];
+    /**
+     * The demand relations by what they ask for, so a caller can read
+     * what the rules are waiting on and go and get it: a store that
+     * loads facts lazily reads the demand on a module's exports and
+     * extracts that module.
+     */
+    demands: Demand[];
 }
 /**
  * Rewrite `rules` so the relations listed in `complete` still come out
@@ -419,4 +438,4 @@ declare function evaluate<Tag = never>(db: Database, rules: Rule[], algebra?: Ta
  */
 declare function clearRelations(db: Database, rules: Rule[], relations: readonly string[]): void;
 
-export { type AddOutcome, type Atom, type BodyMatch, type ConfidenceLevel, Database, type Derivation, type EvaluationProfile, type Literal, type OnDemandRules, type Proof, type ProofDerived, type ProofOptions, type Rule, type RuleCost, type TagAlgebra, type Term, type Tuple, Witness, type WitnessTag, clearRelations, confidence, confidenceWith, constant, deriveOnDemand, evaluate, formatProfile, lit, notLit, profileEvaluation, profileEvaluationAsync, proofOf, rule, ruleLabel, stratify, tupleKey, tupleKeyParts, variable, witnesses };
+export { type AddOutcome, type Atom, type BodyMatch, type ConfidenceLevel, Database, type Demand, type Derivation, type EvaluationProfile, type Literal, type OnDemandRules, type Proof, type ProofDerived, type ProofOptions, type Rule, type RuleCost, type TagAlgebra, type Term, type Tuple, Witness, type WitnessTag, clearRelations, confidence, confidenceWith, constant, deriveOnDemand, evaluate, formatProfile, lit, notLit, profileEvaluation, profileEvaluationAsync, proofOf, rule, ruleLabel, stratify, tupleKey, tupleKeyParts, variable, witnesses };

package/dist/index.js

@@ -47,7 +47,8 @@ function deriveOnDemand(rules, complete) {
   }
   while (pending.length > 0) {
     const adorned = pending.pop();
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const adornments = bodyAdornments(r, adorned.adornment, derives);
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
@@ -70,6 +71,7 @@ function deriveOnDemand(rules, complete) {
   const demandOn = (relation, adornment) => `wanted:${nameOf(relation, adornment)}`;
   const rewritten = [];
   const demandDriven = /* @__PURE__ */ new Set();
+  const demands = [];
   const already = /* @__PURE__ */ new Set();
   const emit = (r) => {
     const key = JSON.stringify(r);
@@ -82,8 +84,14 @@ function deriveOnDemand(rules, complete) {
     if (anyBound(adorned.adornment)) {
       demandDriven.add(nameOf(adorned.relation, adorned.adornment));
       demandDriven.add(demandOn(adorned.relation, adorned.adornment));
+      demands.push({
+        relation: adorned.relation,
+        bound: adorned.adornment,
+        demand: demandOn(adorned.relation, adorned.adornment)
+      });
     }
-    for (const r of rulesByHead.get(adorned.relation) ?? []) {
+    for (const written of rulesByHead.get(adorned.relation) ?? []) {
+      const r = boundFirst(written, adorned.adornment);
       const guard = anyBound(adorned.adornment) ? [
         positiveLiteral(
           demandOn(adorned.relation, adorned.adornment),
@@ -95,13 +103,14 @@ function deriveOnDemand(rules, complete) {
       r.body.forEach((literal, at) => {
         const adornment = adornments[at];
         if (adornment !== null && anyBound(adornment)) {
-          emit({
-            head: {
-              relation: demandOn(literal.relation, adornment),
-              terms: boundTerms(literal.terms, adornment)
-            },
-            body: [...guard, ...body]
-          });
+          const demand = positiveLiteral(
+            demandOn(literal.relation, adornment),
+            boundTerms(literal.terms, adornment)
+          );
+          const premises = [...guard, ...body];
+          if (!sameLiteral(premises, demand)) {
+            emit({ head: demand, body: premises });
+          }
         }
         body.push(
           adornment === null ? literal : positiveLiteral(
@@ -120,7 +129,37 @@ function deriveOnDemand(rules, complete) {
     }
   }
   demandRewrites.add(rewritten);
-  return { rules: rewritten, demandDriven: [...demandDriven] };
+  return { rules: rewritten, demandDriven: [...demandDriven], demands };
+}
+var sameLiteral = (premises, conclusion) => premises.length === 1 && JSON.stringify(premises[0]) === JSON.stringify(conclusion);
+function boundFirst(r, headAdornment) {
+  const bound = /* @__PURE__ */ new Set();
+  r.head.terms.forEach((term, column) => {
+    if (headAdornment[column] && term.type === "variable") {
+      bound.add(term.name);
+    }
+  });
+  const boundColumns = (literal) => literal.terms.filter(
+    (term) => term.type === "constant" || bound.has(term.name)
+  ).length;
+  const remaining = [...r.body];
+  const body = [];
+  while (remaining.length > 0) {
+    let pick = 0;
+    for (let at = 1; at < remaining.length; at++) {
+      if (boundColumns(remaining[at]) > boundColumns(remaining[pick])) {
+        pick = at;
+      }
+    }
+    const [literal] = remaining.splice(pick, 1);
+    body.push(literal);
+    for (const term of literal.terms) {
+      if (term.type === "variable") {
+        bound.add(term.name);
+      }
+    }
+  }
+  return { head: r.head, body };
 }
 function bodyAdornments(r, headAdornment, derives) {
   const bound = /* @__PURE__ */ new Set();
@@ -303,7 +342,13 @@ function formatProfile(profile) {
 
 // src/tupleKey.ts
 var atomKey = (a) => typeof a === "number" ? `n${a}:` : `s${a.length}:${a}`;
-var tupleKey = (parts) => parts.map(atomKey).join("");
+var tupleKey = (parts) => {
+  let key = "";
+  for (let i = 0; i < parts.length; i++) {
+    key += atomKey(parts[i]);
+  }
+  return key;
+};
 function tupleKeyParts(key) {
   const parts = [];
   let at = 0;
@@ -437,7 +482,16 @@ 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 keyOf2 = (tuple) => tupleKey(tuple);
+var keys = /* @__PURE__ */ new WeakMap();
+var keyOf2 = (tuple) => {
+  const known = keys.get(tuple);
+  if (known !== void 0) {
+    return known;
+  }
+  const key = tupleKey(tuple);
+  keys.set(tuple, key);
+  return key;
+};
 function tagSlots(relation) {
   if (relation.tags === void 0) {
     relation.tags = /* @__PURE__ */ new Map();
@@ -569,9 +623,7 @@ var Database = class {
       relation.keys.delete(key);
       relation.tags?.delete(key);
     }
-    relation.tuples = relation.tuples.filter(
-      (tuple) => !going.has(keyOf2(tuple))
-    );
+    relation.tuples = relation.keys.size === 0 ? [] : relation.tuples.filter((tuple) => !going.has(keyOf2(tuple)));
     relation.indexes.clear();
     forgetFacts(this, relationName, going);
     return going.size;
@@ -681,29 +733,90 @@ function headTuple(head, bindings) {
     return bound;
   });
 }
+var variablesOf = (literal) => literal.terms.filter((term) => term.type === "variable").map((term) => term.name);
+var plans = /* @__PURE__ */ new WeakMap();
+function bodyPlan(r, deltaIndex) {
+  let byDelta = plans.get(r);
+  if (byDelta === void 0) {
+    byDelta = /* @__PURE__ */ new Map();
+    plans.set(r, byDelta);
+  }
+  const known = byDelta.get(deltaIndex);
+  if (known !== void 0) {
+    return known;
+  }
+  const positives = r.body.map((literal, index) => literal.negated ? -1 : index).filter((index) => index !== -1);
+  const deltaAt = positives[deltaIndex] ?? -1;
+  const computed = { deltaAt, order: planBodyOrder(r, deltaAt) };
+  byDelta.set(deltaIndex, computed);
+  return computed;
+}
+function planBodyOrder(r, deltaAt) {
+  const natural = r.body.map((_, i) => i);
+  if (deltaAt <= 0) {
+    return natural;
+  }
+  const taken = r.body.map(() => false);
+  const bound = /* @__PURE__ */ new Set();
+  const order = [];
+  const take = (index) => {
+    taken[index] = true;
+    order.push(index);
+    for (const name of variablesOf(r.body[index])) {
+      bound.add(name);
+    }
+  };
+  const firstWhere = (want) => natural.find((index) => !taken[index] && want(index)) ?? -1;
+  const nextLiteral = () => {
+    const ready = firstWhere(
+      (i) => r.body[i].negated && variablesOf(r.body[i]).every((name) => bound.has(name))
+    );
+    if (ready !== -1) {
+      return ready;
+    }
+    const joined = firstWhere(
+      (i) => !r.body[i].negated && variablesOf(r.body[i]).some((name) => bound.has(name))
+    );
+    if (joined !== -1) {
+      return joined;
+    }
+    const disconnected = firstWhere((i) => !r.body[i].negated);
+    if (disconnected !== -1) {
+      return disconnected;
+    }
+    return firstWhere(() => true);
+  };
+  take(deltaAt);
+  while (order.length < r.body.length) {
+    take(nextLiteral());
+  }
+  return order;
+}
 function evaluateRule(db, deltas, r, deltaIndex) {
   const results = [];
-  const step = (literalIndex, positiveIndex, bindings) => {
-    if (literalIndex === r.body.length) {
+  const { deltaAt, order } = bodyPlan(r, deltaIndex);
+  const step = (orderIndex, bindings) => {
+    if (orderIndex === order.length) {
       results.push(headTuple(r.head, bindings));
       return;
     }
+    const literalIndex = order[orderIndex];
     const literal = r.body[literalIndex];
     if (literal.negated) {
       if (!db.has(literal.relation, groundNegated(literal, bindings))) {
-        step(literalIndex + 1, positiveIndex, bindings);
+        step(orderIndex + 1, bindings);
       }
       return;
     }
-    const source = positiveIndex === deltaIndex ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
+    const source = literalIndex === deltaAt ? deltas.get(literal.relation) ?? [] : boundSource(db, literal, bindings);
     for (const tuple of source) {
       const next = unify(literal, tuple, bindings);
       if (next !== NO_MATCH) {
-        step(literalIndex + 1, positiveIndex + 1, next);
+        step(orderIndex + 1, next);
       }
     }
   };
-  step(0, 0, null);
+  step(0, null);
   return results;
 }
 function boundSource(db, literal, bindings) {
@@ -809,7 +922,7 @@ function claimFact(db, relation, key) {
     state.derived.get(relation)?.delete(key);
   }
 }
-function forgetFacts(db, relation, keys) {
+function forgetFacts(db, relation, keys2) {
   const states = evaluated.get(db);
   if (states === void 0) {
     return;
@@ -818,7 +931,7 @@ function forgetFacts(db, relation, keys) {
     state.marks = null;
     const ledger = state.derived.get(relation);
     if (ledger !== void 0) {
-      for (const key of keys) {
+      for (const key of keys2) {
         ledger.delete(key);
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suss/datalog",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "type": "module",
   "description": "A small semi-naïve Datalog evaluator with stratified negation — the rules engine behind suss's derived program facts.",
   "keywords": [