eyelang 1.3.4 → 1.3.5

package/docs/guide.md

@@ -577,7 +577,7 @@ semidet(edge, 2).
 
 For large programs, keep helper predicates selective, bind arguments early, document intended calling patterns with `mode/3` when helpful, and declare focused output predicates with `materialize/2` when default output would otherwise solve broad helper goals.
 
-When using `not/1` over user-defined predicates, keep the dependency graph stratified: negative dependencies should not participate in recursion. The JavaScript API exposes `program.stratifiedNegation`, `program.negationStratificationErrors`, and `program.assertStratifiedNegation()` so host tools can warn or reject programs that rely on unstratified negation.
+When using `not/1` over user-defined predicates, keep the dependency graph stratified: negative dependencies should not participate in recursion. The JavaScript API exposes `program.stratifiedNegation`, `program.negationStratificationErrors`, and `program.assertStratifiedNegation()` so host tools can warn or reject programs that rely on unstratified negation. The diagnostic is lazy by default; use `{ analyzeNegation: true }` to compute it during parsing or `{ strictNegation: true }` to compute and reject unstratified programs.
 
 ## Implementation limits
 

package/docs/language-reference.md

@@ -371,7 +371,7 @@ p(?x) :- q(?x).
 q(?x) :- not(p(?x)).
 ```
 
-The JavaScript implementation records stratification metadata on `Program` instances: `stratifiedNegation`, `negationStratificationErrors`, `negationDependencies`, and per-group `negationStratum`. Embedders that want to reject non-portable negation can parse with `{ strictNegation: true }` or call `program.assertStratifiedNegation()`.
+The JavaScript implementation records stratification metadata on `Program` instances: `stratifiedNegation`, `negationStratificationErrors`, `negationDependencies`, and per-group `negationStratum`. This diagnostic is computed lazily when one of those properties or helper methods is first read, or eagerly when parsing with `{ analyzeNegation: true }` or `{ strictNegation: true }`. Embedders that want to reject non-portable negation can parse with `{ strictNegation: true }` or call `program.assertStratifiedNegation()`.
 
 ## 9. Standard built-in predicates
 

package/index.d.ts

@@ -12,6 +12,7 @@ export interface EyelangRunOptions {
   sourceMetadata?: boolean;
   markRecursive?: boolean;
   strictNegation?: boolean;
+  analyzeNegation?: boolean;
   [key: string]: unknown;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.3.4",
+  "version": "1.3.5",
   "description": "A small Prolog-like logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/program.js

@@ -14,6 +14,7 @@ export class Program {
       clause.index = index;
       this.indexClause(clause);
     }
+    this._negationAnalysis = null;
     this.applyDeclarations(options);
   }
   static parse(source, options = {}) {
@@ -101,7 +102,7 @@ export class Program {
       }
     }
     if (options.markRecursive !== false) this.markRecursivePredicates();
-    this.analyzeNegationStratification();
+    if (options.analyzeNegation === true || options.strictNegation === true) this.analyzeNegationStratification();
     if (options.strictNegation === true) this.assertStratifiedNegation();
   }
   markRecursivePredicates() {
@@ -192,19 +193,34 @@ export class Program {
     const strata = computeNegationStrata(groups, edges, indexByKey);
     for (const group of groups) group.negationStratum = strata.get(groupKeys.get(group)) ?? null;
 
-    this.negationDependencies = edges;
-    this.negationStratificationErrors = violations;
-    this.stratifiedNegation = violations.length === 0;
+    this._negationAnalysis = {
+      dependencies: edges,
+      errors: violations,
+      stratified: violations.length === 0,
+    };
     return violations;
   }
+  ensureNegationStratification() {
+    if (!this._negationAnalysis) this.analyzeNegationStratification();
+    return this._negationAnalysis;
+  }
+  get negationDependencies() {
+    return this.ensureNegationStratification().dependencies;
+  }
+  get negationStratificationErrors() {
+    return this.ensureNegationStratification().errors;
+  }
+  get stratifiedNegation() {
+    return this.ensureNegationStratification().stratified;
+  }
   assertStratifiedNegation() {
-    const violations = this.negationStratificationErrors ?? this.analyzeNegationStratification();
+    const violations = this.ensureNegationStratification().errors;
     if (violations.length === 0) return true;
     const details = violations.map((edge) => `${edge.from} depends negatively on ${edge.to}`).join('; ');
     throw new Error(`unstratified negation: ${details}`);
   }
   isStratifiedNegation() {
-    return this.stratifiedNegation !== false;
+    return this.ensureNegationStratification().stratified;
   }
 
   hasMaterializeDeclarations() {

package/test/run-regression.mjs

@@ -396,6 +396,23 @@ function apiCases() {
         assertEqual(group.arity, 2, 'group arity');
       },
     },
+    {
+      name: 'program keeps negation diagnostics lazy by default',
+      run: () => {
+        const program = Program.parse('p(a).\nq(?x) :- not(p(?x)).\n');
+        assertEqual(program._negationAnalysis, null, 'analysis starts lazy');
+        assertEqual(program.negationDependencies.length, 1, 'dependency count');
+        assertEqual(program._negationAnalysis !== null, true, 'analysis computed on demand');
+      },
+    },
+    {
+      name: 'analyzeNegation option computes diagnostics eagerly',
+      run: () => {
+        const program = Program.parse('p(a).\nq(?x) :- not(p(?x)).\n', { analyzeNegation: true });
+        assertEqual(program._negationAnalysis !== null, true, 'analysis computed eagerly');
+        assertEqual(program.stratifiedNegation, true, 'stratified negation');
+      },
+    },
     {
       name: 'program reports stratified negation metadata',
       run: () => {