@portll/cobolwork 0.2.140 → 0.3.0

package/lib/control.mjs

@@ -251,6 +251,12 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   const loopBody = new Map();
   const stmtAt = new Map();
   for (const st of prog.statements) if (st.at != null && st.verb !== 'WHEN') stmtAt.set(st.at, st);
+  const unpassedBy = new Map();
+  for (const c of prog.calls || []) {
+    const st = prog.statements[c.stmtIndex];
+    if (st) unpassedBy.set(st, new Set([c.targetTok, ...c.using.filter((a) => a.mode !== 'REFERENCE' && a.tok).map((a) => a.tok)]));
+  }
+  const external = (it) => { for (let a = it; a; a = a.parent) if (a.external) return true; return false; };
   const labelAt = new Map();
   for (const l of prog.labels) if (l.at != null) labelAt.set(l.at, l);
   const labelNames = new Set(prog.labels.map((l) => l.name));
@@ -640,11 +646,14 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       for (const t of n.st.targets || []) add(t);
       if (n.st.verb === 'CALL' || n.st.verb === 'READ' || n.st.verb === 'RETURN') {
         // A callee may write what it is passed by reference, and a READ fills the file's records.
+        // The field naming the program called, and what goes BY CONTENT or BY VALUE, is not passed
+        // for the callee to write - unless it is EXTERNAL, which any program can.
+        const unpassed = n.st.verb === 'CALL' ? unpassedBy.get(n.st) : null;
         for (const t of n.st.sources || []) {
           const f = resolve(t);
           if (!f) continue;
           if (f.records) for (const r of f.records) out.push(r);
-          else if (n.st.verb === 'CALL') out.push(f);
+          else if (n.st.verb === 'CALL' && !(unpassed && unpassed.has(t) && !external(f))) out.push(f);
         }
       }
     }
@@ -1083,7 +1092,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       const bounds = { lo: 1, hi };
       const c = { id: checks.length, key, field, file: list[0].n.st.file, line: list[0].n.st.line, tCons: { numeric: true, lo: 1, loInc: true, hi, hiInc: true }, fCons: null, restricts: false, assigned: true, bounds };
       checks.push(c);
-      for (const a of list) if (Number(a.value) <= hi) (a.upTo ||= []).push(c);
+      // "At most v" alone, which a decrement that cannot go below 0 leaves standing.
+      const top = { id: checks.length, key, field, file: c.file, line: c.line, tCons: { numeric: true, hi, hiInc: true }, fCons: null, restricts: false, assigned: true, bounds: { hi } };
+      checks.push(top);
+      for (const a of list) if (Number(a.value) <= hi) (a.upTo ||= []).push(c, top);
     }
   }
   // Fact numbers: for each check, `x` that it ran (only a restricting one), `t` and `f` that it came
@@ -1419,6 +1431,40 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     (a.n.genStmt ||= []).push(newLo(a.field, v, a.n.st).t);
   }
   // An increment by at least m turns "at least k" into "at least k + m", where the sum fits the field.
+  // The fields a statement only ever lowers, by a constant, and by how much at most.
+  const decrements = (st) => {
+    const seg = segOf(st);
+    let fields = [];
+    let max = 0;
+    const amount = (t) => { const v = t && (t.t === 'word' || t.t === 'num') ? numberOf(constValue([t])) : null; return v != null && Number.isInteger(v) && v >= 0 ? v : null; };
+    if (st.verb === 'SUBTRACT') {
+      const from = seg.findIndex((t) => WORD(t, 'FROM'));
+      if (from < 1 || seg.some((t) => WORD(t, 'GIVING') || WORD(t, 'CORRESPONDING') || WORD(t, 'CORR'))) return null;
+      for (const t of seg.slice(0, from)) { const v = amount(t); if (v == null) return null; max += v; }
+      const end = seg.findIndex((t, i) => i > from && PHRASE_AT(t));
+      if (seg.slice(from + 1, end < 0 ? seg.length : end).some((t) => t.t === 'sep')) return null;
+      fields = (st.targets || []).map((t) => resolve(t));
+    } else if (st.verb === 'SET') {
+      const down = seg.findIndex((t) => WORD(t, 'DOWN'));
+      if (down < 1 || !WORD(seg[down + 1], 'BY') || seg.length !== down + 3 || seg.slice(0, down).some((t) => t.t !== 'word')) return null;
+      max = amount(seg[down + 2]);
+      if (max == null) return null;
+      fields = (st.targets || []).map((t) => resolve(t));
+    } else if (st.verb === 'COMPUTE') {
+      const eq = seg.findIndex((t) => t.t === 'op' && t.v === '=');
+      const lhs = seg.slice(0, eq).filter((t) => !WORD(t, 'ROUNDED'));
+      const end = seg.findIndex((t, i) => i > eq && PHRASE_AT(t));
+      const rhs = seg.slice(eq + 1, end < 0 ? seg.length : end);
+      if (eq < 1 || lhs.length !== 1 || lhs[0].t !== 'word' || rhs.length !== 3 || rhs[1].t !== 'op' || rhs[1].v !== '-') return null;
+      const target = resolve(lhs[0]);
+      if (rhs[0].t !== 'word' || resolve(rhs[0]) !== target) return null;
+      max = amount(rhs[2]);
+      if (max == null) return null;
+      fields = [target];
+    } else return null;
+    fields = [...new Set(fields.filter((f) => intCap(f) != null))];
+    return fields.length ? { fields, max } : null;
+  };
   const lifted = new Map();
   for (const [id, inc] of raisers) {
     const list = [];
@@ -1712,7 +1758,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const r = rangeOfField(leaf.f);
     const base = { needs: [], lo: r.hold.lo, hi: r.hold.hi };
     if (!leaf.plain) return [base];
-    const cv = numberOf(constValue([leaf.tok]));
+    const cv = leaf.tok ? numberOf(constValue([leaf.tok])) : null;
     if (cv != null && Number.isInteger(cv)) return [{ needs: [], lo: BigInt(cv), hi: BigInt(cv) }];
     if (!heldBits) return [base];
     let lo = null;
@@ -1729,7 +1775,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const needs = [...new Set([lo && lo.bit, hi && hi.bit].filter((x) => x != null))].sort((x, y) => x - y);
     const from = lo ? lo.v : base.lo;
     const to = hi ? hi.v : base.hi;
-    return needs.length && from <= to ? [base, { needs, lo: from, hi: to }] : [base];
+    if (!needs.length || from > to) return [base];
+    // Each end alone as well, so a result that needs only one of them does not wait on the other.
+    const ends = lo && hi && lo.bit !== hi.bit ? [{ needs: [lo.bit], lo: lo.v, hi: base.hi }, { needs: [hi.bit], lo: base.lo, hi: hi.v }] : [];
+    return [base, { needs, lo: from, hi: to }, ...ends];
   };
   // A fact "the field holds a whole number from lo to hi" (either end may be open), one per field and interval.
   const derivedOf = new Map();
@@ -1769,6 +1818,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // is not among them: the interval is what the data holds, not a test that ran.
   const withLooser = (fact) => {
     const out = [fact.t];
+    if (fact.pair) {
+      for (const [k, other] of pairFacts.get(fact.pairKey)) if (k > fact.k && (fact.pair === 'span' || other.a === fact.a)) out.push(other.t);
+      return out;
+    }
     const own = fact.bounds;
     for (const c of factsByKey.get(fact.key) || []) {
       if (c === fact || !c.derived) continue;
@@ -1781,9 +1834,19 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     }
     return out;
   };
+  // The derived intervals that hold every whole number from lo to hi, an open end holding nothing.
+  const containing = (key, lo, hi) => {
+    const out = [];
+    for (const c of factsByKey.get(key) || []) {
+      if (!c.derived) continue;
+      const e = wholeEnds(c.tCons);
+      if (e && (e.lo == null || (lo != null && e.lo <= lo)) && (e.hi == null || (hi != null && e.hi >= hi))) out.push(c.t);
+    }
+    return out;
+  };
   const expandRules = () => {
     indexFacts();
-    for (const n of nodes) { n.derive = undefined; n.genArith = undefined; }
+    for (const n of nodes) { n.derive = undefined; n.genArith = undefined; n.genArithOn = undefined; }
     for (const r of rules) {
       const bits = withLooser(r.fact);
       const at = r.bucket == null ? r.n : nodes[r.n.test];
@@ -1792,6 +1855,26 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         else ((at.genArithOn ||= { true: [], false: [] })[r.bucket]).push(...bits);
       } else (r.n.derive ||= []).push({ needs: r.needs, to: bits });
     }
+    // A constant moved, and a check's outcome, are values too: routes that reached an interval by
+    // arithmetic and routes that reached it by a move or a test meet at it.
+    for (const a of assigns) {
+      const v = numberOf(a.value);
+      if (v == null || !Number.isInteger(v)) continue;
+      const bits = containing(fieldKey(a.field), BigInt(v), BigInt(v));
+      if (bits.length) (a.n.genArith ||= []).push(...bits);
+    }
+    for (const id of tests) {
+      const n = nodes[id];
+      for (const c of n.checks || []) {
+        for (const [cons, bucket] of [[c.tCons, 'true'], [c.fCons, 'false']]) {
+          if (!cons || (cons.set && cons.set.size)) continue;
+          const e = wholeEnds(cons);
+          if (!e || (e.lo == null && e.hi == null)) continue;
+          const bits = containing(c.key, e.lo, e.hi);
+          if (bits.length) ((n.genArithOn ||= { true: [], false: [] })[bucket]).push(...bits);
+        }
+      }
+    }
   };
 
   const ARITH_VERBS = new Set(['COMPUTE', 'ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MOVE']);
@@ -1971,6 +2054,108 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     relations.clear();
   }
 
+  // Facts over two whole-number fields, killed by a write to either: "A - B <= k" (an order) and
+  // "A + B <= k" (a span, which keeps a reference modification X(A:B) inside X). They are drawn
+  // only for the start and length of a reference modification and the fields a length is computed from.
+  const spanPairs = new Map();
+  for (const st of prog.statements) {
+    for (const x of st.indexes || []) {
+      if (x.kind !== 'refmod-length' || !x.from || !x.from.tok) continue;
+      const len = x.tok && x.tok.t === 'word' ? resolve(x.tok) : null;
+      const start = resolve(x.from.tok);
+      if (!len || !start || len === start || !rangeOfField(len) || !rangeOfField(start) || inTable(len) || inTable(start)) continue;
+      if (!spanPairs.has(len)) spanPairs.set(len, new Set());
+      spanPairs.get(len).add(start);
+    }
+  }
+  const starts = new Set([...spanPairs.values()].flatMap((s) => [...s]));
+  const pairIds = new Map();
+  const pairId = (f) => { if (!pairIds.has(f)) pairIds.set(f, pairIds.size); return pairIds.get(f); };
+  const pairFacts = new Map();
+  const pairKey = (kind, a, b) => (kind === 'span' && pairId(a) > pairId(b) ? `${kind}|${pairId(b)}|${pairId(a)}` : `${kind}|${pairId(a)}|${pairId(b)}`);
+  const pairFact = (kind, a, b, k, at) => {
+    const key = pairKey(kind, a, b);
+    if (!pairFacts.has(key)) pairFacts.set(key, new Map());
+    const mine = pairFacts.get(key);
+    if (mine.has(k)) return mine.get(k);
+    if (!arithBudget()) return null;
+    const fact = { pair: kind, pairKey: key, a, b, k, t: nFacts++, file: at.file, line: at.line };
+    for (const f of [a, b]) {
+      const fk = fieldKey(f);
+      noteField(fk, f);
+      checks.push({ pseudo: true, key: fk, field: f, x: null, t: fact.t, f: null });
+    }
+    mine.set(k, fact);
+    return fact;
+  };
+  // What an outcome makes true of two fields, as order and span facts: S <= E, S + L - 1 <= 80.
+  const pairsOf = (rel, pol) => {
+    const op = pol ? rel.op : NEGATE[rel.op];
+    if (!['<', '<=', '>', '>=', '='].includes(op)) return [];
+    const l = linearOf(rel.left), r = linearOf(rel.right);
+    const e = l && r ? linAdd(l, r, -1) : null;
+    if (!e || e.terms.size !== 2 || e.lo !== e.hi || !Number.isInteger(e.lo)) return [];
+    const out = [];
+    // e op 0 as one or two facts "sum <= k" over the terms, each with its signs.
+    const below = (sign, strict) => {
+      const terms = [...e.terms].map(([f, c]) => [f, sign * c]);
+      if (terms.some(([f, c]) => Math.abs(c) !== 1 || !rangeOfField(f) || inTable(f))) return;
+      const k = -sign * e.lo - (strict ? 1 : 0);
+      const [[a, ca], [b, cb]] = terms;
+      if (ca > 0 && cb > 0) { if ((spanPairs.get(a)?.has(b)) || (spanPairs.get(b)?.has(a))) out.push(['span', a, b, k]); }
+      else if (ca > 0 && cb < 0) { if (starts.has(a)) out.push(['order', a, b, k]); }
+      else if (ca < 0 && cb > 0) { if (starts.has(b)) out.push(['order', b, a, k]); }
+    };
+    if (op === '<' || op === '<=' || op === '=') below(1, op === '<');
+    if (op === '>' || op === '>=' || op === '=') below(-1, op === '>');
+    return out;
+  };
+  if (spanPairs.size) {
+    for (const id of tests) {
+      const n = nodes[id];
+      if (!n.tree) continue;
+      for (const o of [true, false]) {
+        const at = outcomeAt.get(`${id}|${o}`);
+        if (!at) continue;
+        for (const { rel, pol } of relationsOf(n.tree, o)) {
+          for (const [kind, a, b, k] of pairsOf(rel, pol)) {
+            const fact = pairFact(kind, a, b, k, n.at || n.st);
+            if (fact) derive(at, [], fact, String(o));
+          }
+        }
+      }
+    }
+  }
+  // The statements that only raise a field of a span, by at most `max`.
+  const spanRaisers = [];
+  if (spanPairs.size) {
+    const spanFields = new Set([...spanPairs.keys(), ...starts]);
+    nodes.forEach((n, id) => {
+      if (n.kind !== 'stmt' || !n.st || n.st.at == null) return;
+      const inc = increments(n.st);
+      if (inc && inc.fields.some((f) => spanFields.has(f))) spanRaisers.push({ id, inc, wrote: writtenBy(n) });
+    });
+  }
+  const spanLifted = new Set();
+  // An arithmetic tree as whole-number coefficients per plain field plus a whole constant, or null.
+  const linearTree = (t) => {
+    switch (t.k) {
+      case 'const': return t.v.d === 1n ? { terms: new Map(), c: Number(t.v.n) } : null;
+      case 'field': return t.plain ? { terms: new Map([[t.f, 1]]), c: 0 } : null;
+      case 'neg': { const a = linearTree(t.a); return a && { terms: new Map([...a.terms].map(([f, c]) => [f, -c])), c: -a.c }; }
+      case 'bin': {
+        if (t.op !== '+' && t.op !== '-') return null;
+        const a = linearTree(t.a), b = linearTree(t.b);
+        if (!a || !b) return null;
+        const sign = t.op === '+' ? 1 : -1;
+        const terms = new Map(a.terms);
+        for (const [f, c] of b.terms) { const v = (terms.get(f) || 0) + sign * c; if (v) terms.set(f, v); else terms.delete(f); }
+        return { terms, c: a.c + sign * b.c };
+      }
+      default: return null;
+    }
+  };
+
   // The fields that matter: those an index reads, and those that flow into them through the
   // statements above and the relations between fields.
   const relevant = new Set();
@@ -1985,6 +2170,8 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const before = relevant.size;
     for (const a of arith) if (a.targets.some((r) => r.f && relevant.has(r.f))) for (const tree of a.trees) for (const l of tree ? leaves(tree) : []) relevant.add(l.f);
     for (const r of relations.values()) if (relevant.has(r.f) || relevant.has(r.g)) { relevant.add(r.f); relevant.add(r.g); }
+    // A loop condition that bounds a relevant counter through another field makes that field relevant.
+    for (const c of checks) { if (c.pseudo || !c.field || !relevant.has(c.field)) continue; for (const d of [c.tDep, c.fDep]) if (d?.g) relevant.add(d.g); }
     more = relevant.size > before;
   }
 
@@ -1996,20 +2183,77 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     let grew = false;
     try {
     indexFacts();
+    // A check's outcome as an interval of its own, which arithmetic's intervals can widen into at a join.
+    for (const id of tests) {
+      for (const c of nodes[id].checks || []) {
+        if (!relevant.has(c.field) || !rangeOfField(c.field) || inTable(c.field)) continue;
+        for (const cons of [c.tCons, c.fCons]) {
+          if (!cons || (cons.set && cons.set.size)) continue;
+          const e = wholeEnds(cons);
+          if (!e || (e.lo == null && e.hi == null)) continue;
+          const had = derivedOf.get(c.field)?.size || 0;
+          derivedFact(c.field, e.lo, e.hi, nodes[id].at || nodes[id].st);
+          if ((derivedOf.get(c.field)?.size || 0) > had) grew = true;
+        }
+      }
+    }
     for (const a of arith) {
       a.trees.forEach((tree, i) => {
         const r = a.targets[i];
         if (!tree || !r.f || !rangeOfField(r.f) || inTable(r.f) || !relevant.has(r.f)) return;
-        const fit = rangeOfField(r.f).fit;
+        const { fit, hold } = rangeOfField(r.f);
         heldBits = prev ? prev.get(a.n.id) || null : null;
         for (const c of candidates(tree, leafCands, 64)) {
           const s = storedRange(c.iv, r.rounded);
-          if (s.lo < fit.lo || s.hi > fit.hi || (s.lo === fit.lo && s.hi === fit.hi)) continue;
-          const fact = derivedFact(r.f, s.lo, s.hi, a.n.st);
+          if (s.lo === fit.lo && s.hi === fit.hi) continue;
+          // A result past one end of what the field keeps loses high digits and keeps its sign, and no
+          // result past what the storage holds is added, so the other end still bounds it.
+          const whole = s.lo >= fit.lo && s.hi <= fit.hi;
+          const top = whole || (s.lo >= hold.lo && s.hi <= fit.hi && (s.hi >= 0n || s.lo >= fit.lo));
+          const bottom = whole || (s.hi <= hold.hi && s.lo >= fit.lo && (s.lo <= 0n || s.hi <= fit.hi));
+          if (!top && !bottom) continue;
+          const fact = derivedFact(r.f, bottom ? s.lo : null, top ? s.hi : null, a.n.st);
           if (fact && derive(a.n, c.needs, fact)) grew = true;
         }
       });
     }
+    // A length computed as E - S + c from its start S, where S <= E + d held, is at least c - d, which
+    // intervals alone cannot see; and S + L is then E + c, at most what E could hold plus c.
+    for (const a of arith) {
+      a.trees.forEach((tree, i) => {
+        const r = a.targets[i];
+        const mates = r.f && spanPairs.get(r.f);
+        const lin = mates && tree ? linearTree(tree) : null;
+        if (!lin) return;
+        const fit = rangeOfField(r.f).fit;
+        heldBits = prev ? prev.get(a.n.id) || null : null;
+        for (const [s, cs] of lin.terms) {
+          if (cs !== -1 || !mates.has(s) || s === r.f) continue;
+          const rest = [...lin.terms].filter(([f]) => f !== s);
+          if (rest.length > 1 || (rest.length && (rest[0][1] !== 1 || rest[0][0] === r.f))) continue;
+          const e = rest.length ? rest[0][0] : null;
+          const orders = e ? [...(pairFacts.get(pairKey('order', s, e))?.values() || [])] : [];
+          const eCands = e ? leafCands({ f: e, tok: null, plain: true }) : [{ needs: [], lo: 0n, hi: 0n }];
+          const sCands = leafCands({ f: s, tok: null, plain: true });
+          // With no E, the lowest L is c less S's highest, which an interval of S already gives.
+          const floors = e ? orders.map((o) => ({ needs: [o.t], lo: BigInt(lin.c - o.k) })) : sCands.map((sc) => ({ needs: sc.needs, lo: BigInt(lin.c) - sc.hi }));
+          for (const fl of floors) {
+            if (fl.lo < fit.lo) continue;
+            for (const ec of eCands) {
+              for (const sc of sCands) {
+                const hi = ec.hi - sc.lo + BigInt(lin.c);
+                if (hi > fit.hi || hi < fl.lo) continue;
+                const needs = [...new Set([...fl.needs, ...ec.needs, ...sc.needs])].sort((x, y) => x - y);
+                const fact = derivedFact(r.f, fl.lo, hi, a.n.st);
+                if (fact && derive(a.n, needs, fact)) grew = true;
+                const span = pairFact('span', s, r.f, Number(ec.hi) + lin.c, a.n.st);
+                if (span && derive(a.n, needs, span)) grew = true;
+              }
+            }
+          }
+        }
+      });
+    }
     for (const rel of relations.values()) {
       if (!relevant.has(rel.f) && !relevant.has(rel.g)) continue;
       const at = nodes[rel.test].at || nodes[rel.test].st;
@@ -2032,6 +2276,45 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         }
       }
     }
+    // An increment of a span's field by at most n leaves the span n looser: the sum grows by n at most,
+    // and a sum that wraps or is cut short is only lower.
+    for (const { id, inc, wrote } of spanRaisers) {
+      const held = prev ? prev.get(id) : null;
+      if (!held) continue;
+      for (const mine of pairFacts.values()) {
+        for (const f of [...mine.values()]) {
+          if (f.pair !== 'span' || !hasFact(held, f.t)) continue;
+          const count = [f.a, f.b].filter((x) => inc.fields.includes(x)).length;
+          if (!count || wrote.some((w) => !inc.fields.includes(w) && (overlaps(w, f.a) || overlaps(w, f.b)))) continue;
+          const to = pairFact('span', f.a, f.b, f.k + count * inc.max, nodes[id].st);
+          if (!to || spanLifted.has(`${id}|${f.t}|${to.t}`)) continue;
+          spanLifted.add(`${id}|${f.t}|${to.t}`);
+          (nodes[id].spanLifts ||= []).push([f.t, to.t]);
+          grew = true;
+        }
+      }
+    }
+    // A bound over an expression in one other field, X <= G - 1, takes the interval G holds at the test.
+    for (const c of checks) {
+      if (c.pseudo || c.test == null || !relevant.has(c.field) || !rangeOfField(c.field) || inTable(c.field)) continue;
+      for (const o of [true, false]) {
+        const dep = o ? c.tDep : c.fDep;
+        const at = dep && outcomeAt.get(`${c.test}|${o}`);
+        if (!at || !rangeOfField(dep.g) || inTable(dep.g) || !Number.isInteger(dep.m) || !Number.isInteger(dep.b)) continue;
+        const hold = rangeOfField(c.field).hold;
+        heldBits = prev ? prev.get(c.test) || null : null;
+        for (const cand of leafCands({ f: dep.g, tok: null, plain: true })) {
+          const v = BigInt(dep.m) * (dep.needs === 'hi' ? cand.hi : cand.lo) + BigInt(dep.b);
+          let lo = null, hi = null;
+          if (dep.side === 'hi') hi = dep.inc ? v : v - 1n; else lo = dep.inc ? v : v + 1n;
+          if (lo != null && lo <= hold.lo) lo = null;
+          if (hi != null && hi >= hold.hi) hi = null;
+          if ((lo == null && hi == null) || (hi != null && hi < hold.lo) || (lo != null && lo > hold.hi)) continue;
+          const fact = derivedFact(c.field, lo, hi, at.st || nodes[c.test].at || nodes[c.test].st);
+          if (fact && derive(at, cand.needs, fact, String(o))) grew = true;
+        }
+      }
+    }
     // A relation holds after the outcome of its test that makes it true, and the fields it bounds hold
     // what the other side could hold.
     for (const id of tests) {
@@ -2161,6 +2444,31 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     } else if (n.kind === 'step' && stepped.has(id)) {
       keepAcross(n, [{ ...stepped.get(id), sizeError: false }]);
     }
+    // An upper bound survives a decrement that cannot go below 0: one where the field was at least the
+    // amount before it, so nothing is stored as an absolute value or wraps.
+    if (n.kind === 'stmt' && n.st && n.st.at != null) {
+      const dec = decrements(n.st);
+      const wrote = dec ? writtenBy(n) : [];
+      for (const field of dec ? dec.fields : []) {
+        if (wrote.some((w) => w !== field && overlaps(w, field))) continue;
+        const key = fieldKey(field);
+        const keep = [];
+        const guards = [];
+        for (const c of checks) {
+          if (c.key !== key || c.pseudo) continue;
+          for (const [bit, cons] of [[c.t, c.tCons], [c.f, c.fCons]]) {
+            if (bit == null || !cons || cons.dep || (cons.set && cons.set.size)) continue;
+            const r = asRange(cons);
+            if (r.hi != null && r.lo == null) keep.push(bit);
+            if (r.lo != null && (r.loInc ? r.lo : Math.floor(r.lo) + 1) >= dec.max) guards.push(bit);
+          }
+        }
+        if (!keep.length || !guards.length) continue;
+        const bits = new Uint32Array(words);
+        for (const b of keep) bits[b >>> 5] |= 1 << (b & 31);
+        (n.keeps ||= []).push({ bits, guards });
+      }
+    }
     if (n.kind === 'step' && keptOnStep.has(id)) {
       const bits = new Uint32Array(words);
       for (const b of keptOnStep.get(id)) bits[b >>> 5] |= 1 << (b & 31);
@@ -2202,6 +2510,10 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   const killScratch = new Uint32Array(words);
   // A summary is joined to whatever enters the range, so it cannot assume a guard the caller lacks.
   let summarising = false;
+  // While summarising, a fact that depends on others is taken only where the range's own statements
+  // make those others on every route: then it holds whatever the caller brings.
+  let approved = null;
+  const has = (bits, x) => (bits[x >>> 5] & (1 << (x & 31))) !== 0;
   // What holds after a node, in a buffer reused by every call: the caller merges it into the next
   // node's facts before calling again. Null where the route ends here.
   const transfer = (n, input) => {
@@ -2224,7 +2536,7 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
         kill = killScratch;
         kill.set(n.kill);
         for (const k of n.keeps) {
-          if (k.guards && (summarising || !k.guards.some((g) => input[g >>> 5] & (1 << (g & 31))))) continue;
+          if (k.guards && (summarising ? !approved.has(k) : !k.guards.some((g) => has(input, g)))) continue;
           for (let i = 0; i < words; i++) kill[i] &= ~k.bits[i];
         }
       }
@@ -2239,26 +2551,36 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     // An increment that cannot wrap raises the lower bounds that held before it.
     if (n.lifts) {
       for (const { pairs, guards } of n.lifts) {
-        if (summarising || !guards.some((g) => input[g >>> 5] & (1 << (g & 31)))) continue;
-        for (const [from, to] of pairs) {
-          if (!(input[from >>> 5] & (1 << (from & 31)))) continue;
+        if (!summarising && !guards.some((g) => has(input, g))) continue;
+        for (const pair of pairs) {
+          const [from, to] = pair;
+          if (summarising ? !approved.has(pair) : !has(input, from)) continue;
           if (out === input) { scratch.set(input); out = scratch; }
           out[to >>> 5] |= 1 << (to & 31);
         }
       }
     }
+    if (n.spanLifts) {
+      for (const pair of n.spanLifts) {
+        const [from, to] = pair;
+        if (summarising ? !approved.has(pair) : !has(input, from)) continue;
+        if (out === input) { scratch.set(input); out = scratch; }
+        out[to >>> 5] |= 1 << (to & 31);
+      }
+    }
     // What a statement or a test leaves in a field, where the facts its operands needed held before it.
-    if (n.derive && !summarising) {
+    if (n.derive) {
       for (const d of n.derive) {
-        if (!d.needs.every((x) => input[x >>> 5] & (1 << (x & 31)))) continue;
+        if (summarising ? !approved.has(d) : !d.needs.every((x) => has(input, x))) continue;
         if (out === input) { scratch.set(input); out = scratch; }
         for (const t of d.to) out[t >>> 5] |= 1 << (t & 31);
       }
     }
     // A flag test's outcome turns what held before it into the bound the flag stood for.
     if (n.implies) {
-      for (const [from, to, soft] of n.implies) {
-        if (soft && summarising) continue;
+      for (const entry of n.implies) {
+        const [from, to, soft] = entry;
+        if (soft && summarising && !approved.has(entry)) continue;
         if (!(input[from >>> 5] & (1 << (from & 31)))) continue;
         if (out === input) { scratch.set(input); out = scratch; }
         out[to >>> 5] |= 1 << (to & 31);
@@ -2339,8 +2661,22 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
     const r = pending.shift();
     queued.delete(r.key);
     const calls = new Set();
+    // From no facts, every fact the run holds was made inside the range, so what depends on it is sound as it stands.
+    summarising = false;
+    const fromNone = run(r.entry, ZERO, r.end);
+    summarising = true;
+    const bot = fromNone.exitOut;
+    approved = new Set();
+    for (const [id, bits] of fromNone.IN) {
+      const n = nodes[id];
+      for (const k of n.keeps || []) if (k.guards && k.guards.some((g) => has(bits, g))) approved.add(k);
+      for (const { pairs, guards } of n.lifts || []) if (guards.some((g) => has(bits, g))) for (const pair of pairs) if (has(bits, pair[0])) approved.add(pair);
+      for (const pair of n.spanLifts || []) if (has(bits, pair[0])) approved.add(pair);
+      for (const d of n.derive || []) if (d.needs.every((x) => has(bits, x))) approved.add(d);
+      for (const entry of n.implies || []) if (entry[2] && has(bits, entry[0])) approved.add(entry);
+    }
     const top = run(r.entry, ONES, r.end, calls).exitOut;
-    const bot = run(r.entry, ZERO, r.end).exitOut;
+    approved = null;
     for (const k of calls) { if (!callers.has(k)) callers.set(k, new Set()); callers.get(k).add(r); }
     const old = summaries.get(r.key);
     const nextS = top && bot ? { top, bot } : { top: null, bot: null };
@@ -2440,6 +2776,39 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   const posOf = new Map();
   const places = [];
   let placeFacts = nFacts;
+  // The tightest end of a field's value the facts `bits` hold, or its picture's.
+  const boundAt = (g, needs, bits) => {
+    const hold = rangeOfField(g)?.hold;
+    let best = hold ? Number(needs === 'hi' ? hold.hi : hold.lo) : null;
+    if (best != null && !Number.isFinite(best)) best = null;
+    for (const c of checks) {
+      if (c.pseudo || c.key !== fieldKey(g)) continue;
+      for (const [bit, cons] of [[c.t, c.tCons], [c.f, c.fCons]]) {
+        if (!cons || !hasFact(bits, bit)) continue;
+        const e = wholeEnds(cons);
+        const v = e && (needs === 'hi' ? e.hi : e.lo);
+        if (v == null) continue;
+        const n = Number(v);
+        if (best == null || (needs === 'hi' ? n < best : n > best)) best = n;
+      }
+    }
+    return best;
+  };
+  // A relation over an expression, X <= G - 1, read with what G held at the test.
+  const resolveDeps = (map, bits) => {
+    const out = new Map();
+    for (const [key, c] of map) {
+      const dep = c && c.dep;
+      const g = dep ? boundAt(dep.g, dep.needs, bits) : null;
+      if (g == null || !Number.isInteger(dep.m) || !Number.isInteger(dep.b)) { out.set(key, c); continue; }
+      const v = dep.m * g + dep.b;
+      const plain = plainCons(c) || {};
+      const had = plain[dep.side];
+      const tighter = had == null || (dep.side === 'hi' ? v < had : v > had);
+      out.set(key, tighter ? { ...plain, [dep.side]: v, [`${dep.side}Inc`]: dep.inc } : plain);
+    }
+    return out;
+  };
   for (const id of tests) {
     const n = nodes[id];
     if (!n.st || !n.st.indexes || !n.tree || n.evaluate || !(n.st.verb === 'IF' || n.loop)) continue;
@@ -2454,7 +2823,8 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
       for (const g of guards || []) {
         let cons = new Map();
         const r = new Map();
-        for (const [sub, outcome] of g) { cons = meetMaps(cons, consOf(sub, outcome)); testedWhen(sub, outcome, r); }
+        const atTest = facts.get(id);
+        for (const [sub, outcome] of g) { cons = meetMaps(cons, atTest ? resolveDeps(consOf(sub, outcome), atTest) : consOf(sub, outcome)); testedWhen(sub, outcome, r); }
         said = said ? joinMaps(said, cons) : cons;
         ran = ran ? new Map([...ran].filter(([k]) => r.has(k))) : r;
       }
@@ -2501,7 +2871,20 @@ export function buildControl(prog, resolve, { extra = null } = {}) {
   // the caller has let the parse tree go. A statement no context reaches has no facts, and credits
   // nothing. One `reached` does not mark does not run, unless `partial` says the analysis stopped
   // short or met a paragraph the parse did not find.
-  return { loopBody, nodeOf, posOf, checks: checks.filter((c) => !c.pseudo), words, nodes: nodes.length, facts, reached: reachedAt, extraFacts, partial };
+  const spans = [];
+  for (const mine of pairFacts.values()) for (const f of mine.values()) if (f.pair === 'span') spans.push({ a: f.a, b: f.b, k: f.k, t: f.t });
+  return { loopBody, nodeOf, posOf, checks: checks.filter((c) => !c.pseudo), spans, words, nodes: nodes.length, facts, reached: reachedAt, extraFacts, partial };
+}
+
+// The most the facts at a point let a node's value be, as a whole number, or null for no upper end.
+export function topOf(checks, bits) {
+  let cons = null;
+  for (const c of checks || []) for (const [bit, said] of [[c.t, c.tCons], [c.f, c.fCons]]) if (hasFact(bits, bit)) cons = meet(cons, said);
+  return cons ? wholeTop(cons) : null;
+}
+export function wholeTop(said) {
+  const r = asRange(said);
+  return r.hi == null ? null : r.hiInc ? Math.floor(r.hi) : Math.ceil(r.hi) - 1;
 }
 
 // For each token a condition reads, what each reading of it waits on: the operands to its left at