n3 2.1.2 → 2.2.1

package/lib/N3DataFactory.js

@@ -75,6 +75,16 @@ class Term {
 // ## NamedNode constructor
 exports.Term = Term;
 class NamedNode extends Term {
+  // ### Creates a named node
+  /**
+   * @deprecated Create named nodes through a data factory instead
+   * (`DataFactory.namedNode(iri)`), so that term validation can be applied;
+   * the constructor assumes an already-validated IRI.
+   */
+  constructor(iri) {
+    super(iri);
+  }
+
   // ### The term type of this term
   get termType() {
     return 'NamedNode';
@@ -84,6 +94,17 @@ class NamedNode extends Term {
 // ## Literal constructor
 exports.NamedNode = NamedNode;
 class Literal extends Term {
+  // ### Creates a literal
+  /**
+   * @deprecated Create literals through a data factory instead
+   * (`DataFactory.literal(value, languageOrDatatype)`), so that term
+   * validation can be applied; the constructor takes the internal
+   * id representation and assumes it is already valid.
+   */
+  constructor(id) {
+    super(id);
+  }
+
   // ### The term type of this term
   get termType() {
     return 'Literal';
@@ -155,6 +176,12 @@ class Literal extends Term {
 // ## BlankNode constructor
 exports.Literal = Literal;
 class BlankNode extends Term {
+  // ### Creates a blank node
+  /**
+   * @deprecated Create blank nodes through a data factory instead
+   * (`DataFactory.blankNode(name)`), so that term validation can be applied;
+   * the constructor assumes an already-validated name.
+   */
   constructor(name) {
     super(`_:${name}`);
   }
@@ -171,6 +198,12 @@ class BlankNode extends Term {
 }
 exports.BlankNode = BlankNode;
 class Variable extends Term {
+  // ### Creates a variable
+  /**
+   * @deprecated Create variables through a data factory instead
+   * (`DataFactory.variable(name)`), so that term validation can be applied;
+   * the constructor assumes an already-validated name.
+   */
   constructor(name) {
     super(`?${name}`);
   }
@@ -189,6 +222,11 @@ class Variable extends Term {
 // ## DefaultGraph constructor
 exports.Variable = Variable;
 class DefaultGraph extends Term {
+  // ### Creates the default graph
+  /**
+   * @deprecated Obtain the default graph through a data factory instead
+   * (`DataFactory.defaultGraph()`).
+   */
   constructor() {
     super('');
     return DEFAULTGRAPH || this;
@@ -296,6 +334,12 @@ function termToId(term, nested) {
 
 // ## Quad constructor
 class Quad extends Term {
+  // ### Creates a quad
+  /**
+   * @deprecated Create quads through a data factory instead
+   * (`DataFactory.quad(subject, predicate, object, graph)`), so that term
+   * validation can be applied; the constructor assumes already-validated terms.
+   */
   constructor(subject, predicate, object, graph) {
     super('');
     this._subject = subject;

package/lib/N3Lexer.js

@@ -45,8 +45,10 @@ const escapeReplacements = {
   '%': '%'
 };
 const illegalIriChars = /[\x00-\x20<>\\"\{\}\|\^\`]/;
-function isSurrogateCodePoint(charCode) {
-  return charCode >= 0xD800 && charCode <= 0xDFFF;
+
+// A valid code point is a Unicode scalar value: at most U+10FFFF and not a surrogate
+function isValidCodePoint(charCode) {
+  return charCode <= 0x10FFFF && (charCode < 0xD800 || charCode > 0xDFFF);
 }
 const lineModeRegExps = {
   _iri: true,
@@ -425,7 +427,7 @@ class N3Lexer {
       // 4-digit unicode character
       if (typeof unicode4 === 'string') {
         const charCode = Number.parseInt(unicode4, 16);
-        if (isSurrogateCodePoint(charCode)) {
+        if (!isValidCodePoint(charCode)) {
           invalid = true;
           return '';
         }
@@ -434,7 +436,7 @@ class N3Lexer {
       // 8-digit unicode character
       if (typeof unicode8 === 'string') {
         let charCode = Number.parseInt(unicode8, 16);
-        if (isSurrogateCodePoint(charCode)) {
+        if (!isValidCodePoint(charCode)) {
           invalid = true;
           return '';
         }

package/lib/N3Parser.js

@@ -292,6 +292,13 @@ class N3Parser {
       case ';':
         // Additional semicolons can be safely ignored
         return this._predicate !== null ? this._readPredicate : this._error('Expected predicate but got ;', token);
+      case 'literal':
+        if (!this._n3Mode) return this._error('Unexpected literal', token);
+        if (token.prefix.length === 0) {
+          this._literalValue = token.value;
+          return this._completePredicateLiteral;
+        } else this._predicate = this._factory.literal(token.value, this._factory.namedNode(token.prefix));
+        break;
       case '[':
         if (this._n3Mode) {
           // Start a new quad with a new blank node as subject
@@ -481,6 +488,11 @@ class N3Parser {
         if (!this._n3Mode) return this._error('Unexpected graph', token);
         this._saveContext('formula', this._graph, this._subject, this._predicate, this._graph = this._factory.blankNode());
         return this._readSubject;
+      case '<<(':
+        this._saveContext('<<(', this._graph, null, null, null);
+        this._graph = null;
+        next = this._readSubject;
+        break;
       case '<<':
         this._saveContext('<<', this._graph, null, null, null);
         this._graph = null;
@@ -493,8 +505,8 @@ class N3Parser {
     // Create a new blank node if no item head was assigned yet
     if (list === null) this._subject = list = this._factory.blankNode();
 
-    // When reading a reified triple, store the list as subject in the stack, as this will be overridden when reading the triple.
-    if (token.type === '<<') stack[stack.length - 1].subject = this._subject;
+    // When reading a reified triple or triple term, store the list as subject in the stack, as this will be overridden when reading the triple.
+    if (token.type === '<<' || token.type === '<<(') stack[stack.length - 1].subject = this._subject;
 
     // Is this the first element of the list?
     if (previousList === null) {
@@ -569,22 +581,45 @@ class N3Parser {
         language: this._literalLanguage,
         direction: token.value
       });
-      if (component === 'subject') this._subject = term;else this._object = term;
+      if (component === 'subject') this._subject = term;else if (component === 'predicate') this._predicate = term;else this._object = term;
       this._literalLanguage = undefined;
       token = null;
     }
     if (component === 'subject') return token === null ? this._readPredicateOrNamedGraph : this._readPredicateOrNamedGraph(token);
+    if (component === 'predicate') return token === null ? this._readObject : this._readObject(token);
     return this._completeObjectLiteralPost(token, listItem);
   }
 
-  // Completes a literal in subject position
-  _completeSubjectLiteral(token) {
-    const completed = this._completeLiteral(token, 'subject');
-    this._subject = completed.literal;
+  // Completes a literal in subject or predicate position
+  _completeTermLiteral(token, component) {
+    const completed = this._completeLiteral(token, component);
+    if (!completed) return;
+    let next;
+    if (component === 'subject') {
+      this._subject = completed.literal;
+      next = this._readPredicateOrNamedGraph;
+    } else {
+      this._predicate = completed.literal;
+      this._validAnnotation = true;
+      next = this._readObject;
+    }
 
     // Postpone completion if the literal is only partially completed (such as lang+dir).
     if (completed.readCb) return completed.readCb.bind(this, false);
-    return this._readPredicateOrNamedGraph;
+
+    // If the token was consumed as a datatype, continue with the next component;
+    // otherwise, consume the token now
+    return completed.token === null ? next : next.call(this, completed.token);
+  }
+
+  // Completes a literal in subject position
+  _completeSubjectLiteral(token) {
+    return this._completeTermLiteral(token, 'subject');
+  }
+
+  // Completes a literal in predicate position
+  _completePredicateLiteral(token) {
+    return this._completeTermLiteral(token, 'predicate');
   }
 
   // Completes a literal in object position
@@ -899,6 +934,13 @@ class N3Parser {
     const quad = this._factory.quad(this._subject, this._predicate, this._object, this._graph || this.DEFAULTGRAPH);
     this._restoreContext('<<(', token);
 
+    // If we're in a list, continue processing that list
+    const stack = this._contextStack,
+      parent = stack.length && stack[stack.length - 1];
+    if (parent && parent.type === 'list') {
+      this._emit(this._subject, this.RDF_FIRST, quad, this._graph);
+      return this._getContextEndReader();
+    }
     // If the triple was the subject, continue by reading the predicate.
     if (this._subject === null) {
       this._subject = quad;

package/lib/N3Reasoner.js

@@ -26,14 +26,22 @@ function getRulesFromDataset(dataset) {
   return rules;
 }
 class N3Reasoner {
-  constructor(store) {
+  constructor(store, options = {}) {
     this._store = store;
+    // Optional safety budgets for reasoning over untrusted rules or data
+    this._maxDerivations = options.maxDerivations === undefined ? Infinity : options.maxDerivations;
+    // Caps a rule's premise count, as `_evaluatePremise` recurses once per premise
+    this._maxPremiseDepth = options.maxPremiseDepth === undefined ? Infinity : options.maxPremiseDepth;
   }
   _add(subject, predicate, object, graphItem, cb) {
     // Only add to the remaining indexes if there is not already a value in the index
     if (!this._store._addToIndex(graphItem.subjects, subject, predicate, object)) return;
     this._store._addToIndex(graphItem.predicates, predicate, object, subject);
     this._store._addToIndex(graphItem.objects, object, subject, predicate);
+    // Count genuinely new derivations and fail past the budget. The check comes
+    // after all three indexes are updated, so a caught error leaves the store
+    // in a consistent state (the reasoning result is merely incomplete).
+    if (++this._derivations > this._maxDerivations) throw new Error(`Reasoning exceeded the maximum of ${this._maxDerivations} derivations`);
     cb();
   }
   _evaluatePremise(rule, content, cb, i = 0) {
@@ -143,10 +151,18 @@ class N3Reasoner {
     };
   }
   reason(rules) {
+    this._derivations = 0;
     if (!Array.isArray(rules)) {
       rules = getRulesFromDataset(rules);
     }
     rules = rules.map(rule => this._createRule(rule));
+
+    // Reject rules with more body triples than the configured premise depth:
+    // `_evaluatePremise` recurses once per premise, so an over-long rule would
+    // otherwise overflow the stack with an uncatchable RangeError.
+    for (const rule of rules) {
+      if (rule.premise.length > this._maxPremiseDepth) throw new Error(`Reasoning rule exceeds the maximum premise depth of ${this._maxPremiseDepth}`);
+    }
     for (const r1 of rules) {
       for (const r2 of rules) {
         for (let i = 0; i < r2.premise.length; i++) {
@@ -190,10 +206,15 @@ class N3Reasoner {
       rule.premise = rule.premise.map(p => getIndex(p, set));
     }
     const graphs = this._store._getGraphs();
-    for (const graphId in graphs) {
-      this._reasonGraphNaive(rules, graphs[graphId]);
+    try {
+      for (const graphId in graphs) {
+        this._reasonGraphNaive(rules, graphs[graphId]);
+      }
+    } finally {
+      // Invalidate the cached size even if a derivation budget was exceeded,
+      // so a caught budget error leaves the store fully consistent.
+      this._store._size = null;
     }
-    this._store._size = null;
   }
 }
 exports.default = N3Reasoner;

package/lib/N3Store.js

@@ -275,6 +275,18 @@ class N3Store {
     }
   }
 
+  // ### `_loopByKey0Deep` executes the callback on all keys of index 2
+  // for a certain entry in index 0, possibly repeating keys
+  _loopByKey0Deep(index0, key0, callback) {
+    let index1, index2, key1, key2;
+    if (index1 = index0[key0]) {
+      for (key1 in index1) {
+        index2 = index1[key1];
+        for (key2 in index2) callback(key2);
+      }
+    }
+  }
+
   // ### `_countInIndex` counts matching quads in a three-layered index.
   // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.
   // Any of these keys can be undefined, which is interpreted as a wildcard.
@@ -685,8 +697,9 @@ class N3Store {
           if (predicateId)
             // If subject and predicate are given, the SPO index is best.
             this._loopBy2Keys(content.subjects, subjectId, predicateId, callback);else
-            // If only subject is given, the OSP index is best.
-            this._loopByKey1(content.objects, subjectId, callback);
+            // If only subject is given, descending the SPO index
+            // visits only the subject's own quads.
+            this._loopByKey0Deep(content.subjects, subjectId, callback);
         } else if (predicateId)
           // If only predicate is given, the POS index is best.
           this._loopByKey0(content.predicates, predicateId, callback);else

package/lib/N3Writer.js

@@ -46,6 +46,7 @@ class N3Writer {
   constructor(outputStream, options) {
     // ### `_prefixRegex` matches a prefixed name or IRI that begins with one of the added prefixes
     this._prefixRegex = /$0^/;
+    this._hasPrefixes = false;
 
     // Shift arguments if the first argument is not a stream
     if (outputStream && typeof outputStream.write !== 'function') options = outputStream, outputStream = null;
@@ -154,7 +155,7 @@ class N3Writer {
     if (entity.termType !== 'NamedNode') {
       // If it is a list head, pretty-print it
       if (this._lists && entity.value in this._lists) entity = this.list(this._lists[entity.value]);
-      return 'id' in entity ? entity.id : `_:${entity.value}`;
+      return entity.termType === 'Variable' ? `?${entity.value}` : 'id' in entity ? entity.id : `_:${entity.value}`;
     }
     let iri = entity.value;
     // Use relative IRIs if requested and possible
@@ -163,8 +164,8 @@ class N3Writer {
     }
     // Escape special characters
     if (escape.test(iri)) iri = iri.replace(escapeAll, characterReplacer);
-    // Try to represent the IRI as prefixed name
-    const prefixMatch = this._prefixRegex.exec(iri);
+    // Try to represent the IRI as prefixed name, unless no prefixes were added
+    const prefixMatch = this._hasPrefixes ? this._prefixRegex.exec(iri) : null;
     return !prefixMatch ? `<${iri}>` : !prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
   }
 
@@ -282,6 +283,7 @@ class N3Writer {
     }
     // Recreate the prefix matcher
     if (hasPrefixes) {
+      this._hasPrefixes = true;
       let IRIlist = '',
         prefixList = '';
       for (const prefixIRI in this._prefixIRIs) {
@@ -289,7 +291,7 @@ class N3Writer {
         prefixList += (prefixList ? '|' : '') + this._prefixIRIs[prefixIRI];
       }
       IRIlist = (0, _Util.escapeRegex)(IRIlist, /[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
-      this._prefixRegex = new RegExp(`^(?:${prefixList})[^\/]*$|` + `^(${IRIlist})([_a-zA-Z0-9][\\-_a-zA-Z0-9]*)$`);
+      this._prefixRegex = new RegExp(`^(?:${prefixList})[^\/]*$|` + `^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
     }
     // End a prefix block with a newline
     this._write(hasPrefixes ? '\n' : '', done);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [

package/src/N3DataFactory.js

@@ -65,6 +65,16 @@ export class Term {
 
 // ## NamedNode constructor
 export class NamedNode extends Term {
+  // ### Creates a named node
+  /**
+   * @deprecated Create named nodes through a data factory instead
+   * (`DataFactory.namedNode(iri)`), so that term validation can be applied;
+   * the constructor assumes an already-validated IRI.
+   */
+  constructor(iri) {
+    super(iri);
+  }
+
   // ### The term type of this term
   get termType() {
     return 'NamedNode';
@@ -73,6 +83,17 @@ export class NamedNode extends Term {
 
 // ## Literal constructor
 export class Literal extends Term {
+  // ### Creates a literal
+  /**
+   * @deprecated Create literals through a data factory instead
+   * (`DataFactory.literal(value, languageOrDatatype)`), so that term
+   * validation can be applied; the constructor takes the internal
+   * id representation and assumes it is already valid.
+   */
+  constructor(id) {
+    super(id);
+  }
+
   // ### The term type of this term
   get termType() {
     return 'Literal';
@@ -146,6 +167,12 @@ export class Literal extends Term {
 
 // ## BlankNode constructor
 export class BlankNode extends Term {
+  // ### Creates a blank node
+  /**
+   * @deprecated Create blank nodes through a data factory instead
+   * (`DataFactory.blankNode(name)`), so that term validation can be applied;
+   * the constructor assumes an already-validated name.
+   */
   constructor(name) {
     super(`_:${name}`);
   }
@@ -162,6 +189,12 @@ export class BlankNode extends Term {
 }
 
 export class Variable extends Term {
+  // ### Creates a variable
+  /**
+   * @deprecated Create variables through a data factory instead
+   * (`DataFactory.variable(name)`), so that term validation can be applied;
+   * the constructor assumes an already-validated name.
+   */
   constructor(name) {
     super(`?${name}`);
   }
@@ -179,6 +212,11 @@ export class Variable extends Term {
 
 // ## DefaultGraph constructor
 export class DefaultGraph extends Term {
+  // ### Creates the default graph
+  /**
+   * @deprecated Obtain the default graph through a data factory instead
+   * (`DataFactory.defaultGraph()`).
+   */
   constructor() {
     super('');
     return DEFAULTGRAPH || this;
@@ -299,6 +337,12 @@ export function termToId(term, nested) {
 
 // ## Quad constructor
 export class Quad extends Term {
+  // ### Creates a quad
+  /**
+   * @deprecated Create quads through a data factory instead
+   * (`DataFactory.quad(subject, predicate, object, graph)`), so that term
+   * validation can be applied; the constructor assumes already-validated terms.
+   */
   constructor(subject, predicate, object, graph) {
     super('');
     this._subject   = subject;

package/src/N3Lexer.js

@@ -15,8 +15,9 @@ const escapeReplacements = {
 };
 const illegalIriChars = /[\x00-\x20<>\\"\{\}\|\^\`]/;
 
-function isSurrogateCodePoint(charCode) {
-  return charCode >= 0xD800 && charCode <= 0xDFFF;
+// A valid code point is a Unicode scalar value: at most U+10FFFF and not a surrogate
+function isValidCodePoint(charCode) {
+  return charCode <= 0x10FFFF && (charCode < 0xD800 || charCode > 0xDFFF);
 }
 
 const lineModeRegExps = {
@@ -433,7 +434,7 @@ export default class N3Lexer {
       // 4-digit unicode character
       if (typeof unicode4 === 'string') {
         const charCode = Number.parseInt(unicode4, 16);
-        if (isSurrogateCodePoint(charCode)) {
+        if (!isValidCodePoint(charCode)) {
           invalid = true;
           return '';
         }
@@ -442,7 +443,7 @@ export default class N3Lexer {
       // 8-digit unicode character
       if (typeof unicode8 === 'string') {
         let charCode = Number.parseInt(unicode8, 16);
-        if (isSurrogateCodePoint(charCode)) {
+        if (!isValidCodePoint(charCode)) {
           invalid = true;
           return '';
         }

package/src/N3Parser.js

@@ -302,6 +302,18 @@ export default class N3Parser {
       // Additional semicolons can be safely ignored
       return this._predicate !== null ? this._readPredicate :
              this._error('Expected predicate but got ;', token);
+    case 'literal':
+      if (!this._n3Mode)
+        return this._error('Unexpected literal', token);
+
+      if (token.prefix.length === 0) {
+        this._literalValue = token.value;
+        return this._completePredicateLiteral;
+      }
+      else
+        this._predicate = this._factory.literal(token.value, this._factory.namedNode(token.prefix));
+
+      break;
     case '[':
       if (this._n3Mode) {
         // Start a new quad with a new blank node as subject
@@ -508,6 +520,11 @@ export default class N3Parser {
       this._saveContext('formula', this._graph, this._subject, this._predicate,
                         this._graph = this._factory.blankNode());
       return this._readSubject;
+    case '<<(':
+      this._saveContext('<<(', this._graph, null, null, null);
+      this._graph = null;
+      next = this._readSubject;
+      break;
     case '<<':
       this._saveContext('<<', this._graph, null, null, null);
       this._graph = null;
@@ -522,8 +539,8 @@ export default class N3Parser {
     if (list === null)
       this._subject = list = this._factory.blankNode();
 
-    // When reading a reified triple, store the list as subject in the stack, as this will be overridden when reading the triple.
-    if (token.type === '<<')
+    // When reading a reified triple or triple term, store the list as subject in the stack, as this will be overridden when reading the triple.
+    if (token.type === '<<' || token.type === '<<(')
       stack[stack.length - 1].subject = this._subject;
 
     // Is this the first element of the list?
@@ -603,6 +620,8 @@ export default class N3Parser {
       const term = this._factory.literal(this._literalValue, { language: this._literalLanguage, direction: token.value });
       if (component === 'subject')
         this._subject = term;
+      else if (component === 'predicate')
+        this._predicate = term;
       else
         this._object = term;
       this._literalLanguage = undefined;
@@ -611,19 +630,45 @@ export default class N3Parser {
 
     if (component === 'subject')
       return token === null ? this._readPredicateOrNamedGraph : this._readPredicateOrNamedGraph(token);
+    if (component === 'predicate')
+      return token === null ? this._readObject : this._readObject(token);
     return this._completeObjectLiteralPost(token, listItem);
   }
 
-  // Completes a literal in subject position
-  _completeSubjectLiteral(token) {
-    const completed = this._completeLiteral(token, 'subject');
-    this._subject = completed.literal;
+  // Completes a literal in subject or predicate position
+  _completeTermLiteral(token, component) {
+    const completed = this._completeLiteral(token, component);
+    if (!completed)
+      return;
+
+    let next;
+    if (component === 'subject') {
+      this._subject = completed.literal;
+      next = this._readPredicateOrNamedGraph;
+    }
+    else {
+      this._predicate = completed.literal;
+      this._validAnnotation = true;
+      next = this._readObject;
+    }
 
     // Postpone completion if the literal is only partially completed (such as lang+dir).
     if (completed.readCb)
       return completed.readCb.bind(this, false);
 
-    return this._readPredicateOrNamedGraph;
+    // If the token was consumed as a datatype, continue with the next component;
+    // otherwise, consume the token now
+    return completed.token === null ? next : next.call(this, completed.token);
+  }
+
+  // Completes a literal in subject position
+  _completeSubjectLiteral(token) {
+    return this._completeTermLiteral(token, 'subject');
+  }
+
+  // Completes a literal in predicate position
+  _completePredicateLiteral(token) {
+    return this._completeTermLiteral(token, 'predicate');
   }
 
   // Completes a literal in object position
@@ -972,6 +1017,12 @@ export default class N3Parser {
         this._graph || this.DEFAULTGRAPH);
     this._restoreContext('<<(', token);
 
+    // If we're in a list, continue processing that list
+    const stack = this._contextStack, parent = stack.length && stack[stack.length - 1];
+    if (parent && parent.type === 'list') {
+      this._emit(this._subject, this.RDF_FIRST, quad, this._graph);
+      return this._getContextEndReader();
+    }
     // If the triple was the subject, continue by reading the predicate.
     if (this._subject === null) {
       this._subject = quad;

package/src/N3Reasoner.js

@@ -14,8 +14,12 @@ export function getRulesFromDataset(dataset) {
 }
 
 export default class N3Reasoner {
-  constructor(store) {
+  constructor(store, options = {}) {
     this._store = store;
+    // Optional safety budgets for reasoning over untrusted rules or data
+    this._maxDerivations = options.maxDerivations === undefined ? Infinity : options.maxDerivations;
+    // Caps a rule's premise count, as `_evaluatePremise` recurses once per premise
+    this._maxPremiseDepth = options.maxPremiseDepth === undefined ? Infinity : options.maxPremiseDepth;
   }
 
   _add(subject, predicate, object, graphItem, cb) {
@@ -23,6 +27,11 @@ export default class N3Reasoner {
     if (!this._store._addToIndex(graphItem.subjects,   subject,   predicate, object)) return;
     this._store._addToIndex(graphItem.predicates, predicate, object,    subject);
     this._store._addToIndex(graphItem.objects,    object,    subject,   predicate);
+    // Count genuinely new derivations and fail past the budget. The check comes
+    // after all three indexes are updated, so a caught error leaves the store
+    // in a consistent state (the reasoning result is merely incomplete).
+    if (++this._derivations > this._maxDerivations)
+      throw new Error(`Reasoning exceeded the maximum of ${this._maxDerivations} derivations`);
     cb();
   }
 
@@ -129,11 +138,20 @@ export default class N3Reasoner {
   }
 
   reason(rules) {
+    this._derivations = 0;
     if (!Array.isArray(rules)) {
       rules = getRulesFromDataset(rules);
     }
     rules = rules.map(rule => this._createRule(rule));
 
+    // Reject rules with more body triples than the configured premise depth:
+    // `_evaluatePremise` recurses once per premise, so an over-long rule would
+    // otherwise overflow the stack with an uncatchable RangeError.
+    for (const rule of rules) {
+      if (rule.premise.length > this._maxPremiseDepth)
+        throw new Error(`Reasoning rule exceeds the maximum premise depth of ${this._maxPremiseDepth}`);
+    }
+
     for (const r1 of rules) {
       for (const r2 of rules) {
         for (let i = 0; i < r2.premise.length; i++) {
@@ -179,11 +197,16 @@ export default class N3Reasoner {
     }
 
     const graphs = this._store._getGraphs();
-    for (const graphId in graphs) {
-      this._reasonGraphNaive(rules, graphs[graphId]);
+    try {
+      for (const graphId in graphs) {
+        this._reasonGraphNaive(rules, graphs[graphId]);
+      }
+    }
+    finally {
+      // Invalidate the cached size even if a derivation budget was exceeded,
+      // so a caught budget error leaves the store fully consistent.
+      this._store._size = null;
     }
-
-    this._store._size = null;
   }
 }