eyeling 1.33.1 → 1.33.3

package/lib/eyelang/builtins/{registry.mjs → registry.js}

@@ -1,19 +1,18 @@
 // Registry for builtins and their execution metadata.
 // The solver uses the metadata to know when a builtin is deterministic, mode-ready, or should fall back to user clauses.
-import { arithmeticBuiltins } from './arithmetic.mjs';
-import { coreBuiltins } from './core.mjs';
-import { stringBuiltins } from './strings.mjs';
-import { listBuiltins } from './lists.mjs';
-import { aggregationBuiltins } from './aggregation.mjs';
-import { formulaBuiltins } from './formula.mjs';
-import { controlBuiltins } from './control.mjs';
-import { sudokuBuiltins } from './sudoku.mjs';
-import { portfolioBuiltins } from './portfolio.mjs';
-import { searchBuiltins } from './search.mjs';
-import { numberTheoryBuiltins } from './number-theory.mjs';
-import { matrixBuiltins } from './matrix.mjs';
-import { alphameticBuiltins } from './alphametic.mjs';
-import { n3Builtins } from './n3.mjs';
+import { arithmeticBuiltins } from './arithmetic.js';
+import { coreBuiltins } from './core.js';
+import { stringBuiltins } from './strings.js';
+import { listBuiltins } from './lists.js';
+import { aggregationBuiltins } from './aggregation.js';
+import { formulaBuiltins } from './formula.js';
+import { controlBuiltins } from './control.js';
+import { sudokuBuiltins } from './sudoku.js';
+import { portfolioBuiltins } from './portfolio.js';
+import { searchBuiltins } from './search.js';
+import { numberTheoryBuiltins } from './number-theory.js';
+import { matrixBuiltins } from './matrix.js';
+import { alphameticBuiltins } from './alphametic.js';
 
 export class BuiltinRegistry {
   constructor() {
@@ -40,7 +39,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, formulaBuiltins, controlBuiltins, sudokuBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins, n3Builtins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, formulaBuiltins, controlBuiltins, sudokuBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/lib/eyelang/builtins/{search.mjs → search.js}

@@ -2,8 +2,8 @@
 // of their time in small relational generators.  These predicates are generic
 // entry points (graph, CNF, QMC, range, and n-queens helpers), not compiled
 // replacements for particular example predicate names.
-import { atom, compound, deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
-import { compareLexicalOrNumeric } from './arithmetic.mjs';
+import { atom, compound, deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
+import { compareLexicalOrNumeric } from './arithmetic.js';
 
 export const searchBuiltins = {
   register(registry) {
@@ -230,9 +230,9 @@ function undirectedGraph(program, predicate) {
 }
 
 function* fixedLengthCycle({ solver, goal, env }) {
-  // fixed_length_cycle(EdgePred, Length, Relation, Cycle) is useful for RDF-like
-  // edge(Source, Relation, Target) data. It enumerates closed walks of exactly
-  // Length steps and returns the relation label and node list.
+  // fixed_length_cycle(EdgePred, Length, Relation, Cycle) is useful for
+  // labelled edge(Source, Relation, Target) data. It enumerates closed walks
+  // of exactly Length steps and returns the relation label and node list.
   const predicate = atomKey(deref(goal.args[0], env));
   const length = intTerm(goal.args[1], env);
   if (!predicate || length == null || length < 0) return;

package/lib/eyelang/builtins/{strings.mjs → strings.js}

@@ -1,6 +1,6 @@
 // String and atom conversion builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { atom, lexicalValue, stringTerm, unify } from '../term.mjs';
+import { atom, lexicalValue, stringTerm, unify } from '../term.js';
 
 export const stringBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{sudoku.mjs → sudoku.js}

@@ -1,6 +1,6 @@
 // Sudoku-specific helpers used by the example suite.
 // The cover9/1 optimization prunes invalid row blocks early while leaving the declarative fallback available.
-import { deref, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+import { deref, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
 
 export const sudokuBuiltins = {
   register(registry) {

package/lib/eyelang/{cli.mjs → cli.js}

@@ -18,7 +18,6 @@ export async function main(argv) {
     proof: false,
     stats: false,
     version: false,
-    inputFormat: 'auto',
   };
 
   let endOptions = false;
@@ -37,14 +36,6 @@ export async function main(argv) {
       options.proof = true;
     } else if (!endOptions && (arg === '--stats' || arg === '-s')) {
       options.stats = true;
-    } else if (!endOptions && (arg === '--rdf' || arg === '--rdf12')) {
-      options.inputFormat = 'rdf12';
-    } else if (!endOptions && arg === '--n3') {
-      options.inputFormat = 'n3';
-    } else if (!endOptions && arg === '--input-format') {
-      const value = argv[++i];
-      if (!value) throw new Error('--input-format needs a value');
-      options.inputFormat = value;
     } else if (!endOptions && arg.startsWith('-') && arg !== '-') {
       throw new Error(`unknown option: ${arg}`);
     } else {
@@ -79,7 +70,7 @@ export async function main(argv) {
   }
 
   const engine = await loadEngine();
-  const program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof, inputFormat: options.inputFormat });
+  const program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof });
 
   await runDefault(engine, program, options);
 }
@@ -87,10 +78,10 @@ export async function main(argv) {
 async function loadEngine() {
   if (engineModule == null) {
     const [term, program, solver, registry] = await Promise.all([
-      import('./term.mjs'),
-      import('./program.mjs'),
-      import('./solver.mjs'),
-      import('./builtins/registry.mjs'),
+      import('./term.js'),
+      import('./program.js'),
+      import('./solver.js'),
+      import('./builtins/registry.js'),
     ]);
     engineModule = { ...term, ...program, ...solver, ...registry };
   }
@@ -98,7 +89,7 @@ async function loadEngine() {
 }
 
 async function loadExplanation() {
-  if (explanationModule == null) explanationModule = await import('./explain.mjs');
+  if (explanationModule == null) explanationModule = await import('./explain.js');
   return explanationModule;
 }
 
@@ -152,9 +143,6 @@ Options:
   -h, --help            Show this help text and exit.
   -p, --proof           Enable proof explanations.
   -s, --stats           Print solver statistics to stderr after execution.
-  --rdf, --rdf12        Read input as RDF 1.2 Turtle/N-Triples compatibility syntax.
-  --n3                  Read input as Notation3 rule compatibility syntax.
-  --input-format FORMAT Use eyelang, auto, rdf12, turtle, nt, or n3.
   -v, --version         Show the package version and exit.
   --                    Stop option parsing; following arguments are treated as files.
 `);

package/lib/eyelang/{explain.mjs → explain.js}

@@ -2,10 +2,10 @@
 // The explanation printer replays a successful goal against the program and emits
 // ordinary eyelang facts with nested proof terms.  Explanations are therefore both
 // human-readable and machine-readable.
-import { COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.mjs';
-import { selectClauseCandidates } from './program.mjs';
-import { createDefaultRegistry } from './builtins/registry.mjs';
-import { Solver, nextFreshId } from './solver.mjs';
+import { COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { selectClauseCandidates } from './program.js';
+import { createDefaultRegistry } from './builtins/registry.js';
+import { Solver, nextFreshId } from './solver.js';
 
 export function whyProof(program, goal, options = {}) {
   const maxDepth = options.maxDepth ?? 256;

package/lib/eyelang/{hash.mjs → hash.js}

@@ -1,6 +1,6 @@
 // Small dependency-free hashing helpers shared by Node and browser builds.
-// They intentionally avoid node:crypto so src/index.js remains importable by the
-// browser playground when the N3 crypto builtins are registered.
+// They intentionally avoid node:crypto so src/index.js remains importable by
+// browser builds that register hashing builtins.
 
 const textEncoder = new TextEncoder();
 

package/lib/eyelang/{index.mjs → index.js}

@@ -1,17 +1,16 @@
 // Public JavaScript API surface for embedders and the browser playground.
 // The CLI imports the same parser, program, solver, and term primitives from here.
-export { Program, makeProgram } from './program.mjs';
-export { parseClauses, parseProgramText } from './parser.mjs';
-export { parseRdfClauses, rdfToEyelang, clausesToEyelang, rdfIri, rdfBlank, rdfLiteral, rdfTripleTerm, rdfGoal } from './rdf.mjs';
-export { Solver } from './solver.mjs';
-export * from './term.mjs';
-export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.mjs';
+export { Program, makeProgram } from './program.js';
+export { parseClauses, parseProgramText } from './parser.js';
+export { Solver } from './solver.js';
+export * from './term.js';
+export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.js';
 
-import { Env, copyResolved, termIsGround, termToString } from './term.mjs';
-import { Program } from './program.mjs';
-import { Solver } from './solver.mjs';
-import { whyNoProof, whyProof } from './explain.mjs';
-import { getDefaultRegistry } from './builtins/registry.mjs';
+import { Env, copyResolved, termIsGround, termToString } from './term.js';
+import { Program } from './program.js';
+import { Solver } from './solver.js';
+import { whyNoProof, whyProof } from './explain.js';
+import { getDefaultRegistry } from './builtins/registry.js';
 
 export function run(source, options = {}) {
   const includeWhy = options.proof === true || options.why === true || options.explain === true;
@@ -45,4 +44,4 @@ function appendExplanation(output, program, resolved, registry) {
   if (!proof.ok) output.push(whyNoProof(resolved));
 }
 
-export * from './explain.mjs';
+export * from './explain.js';

package/lib/eyelang/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/eyelang/{parser.mjs → parser.js}

@@ -1,6 +1,6 @@
 // Tokenizer and recursive-descent parser for the eyelang source language.
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
-import { atom, compound, cons, emptyList, numberTerm, stringTerm, variable } from './term.mjs';
+import { atom, compound, cons, emptyList, numberTerm, stringTerm, variable } from './term.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',

package/lib/eyelang/{program.mjs → program.js}

@@ -1,8 +1,7 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.mjs';
-import { parseClauses } from './parser.mjs';
-import { filenameLooksRdf, parseRdfClauses } from './rdf.mjs';
+import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.js';
+import { parseClauses } from './parser.js';
 
 export class Program {
   constructor(clauses = [], options = {}) {
@@ -234,11 +233,5 @@ export function makeProgram(source, options = {}) {
 }
 
 export function parseSourceClauses(source, options = {}) {
-  const inputFormat = (options.inputFormat ?? options.format ?? 'eyelang').toString().toLowerCase();
-  const filename = options.filename ?? '<input>';
-  const autoRdf = inputFormat === 'auto' && filenameLooksRdf(filename);
-  if (inputFormat === 'rdf' || inputFormat === 'rdf12' || inputFormat === 'n3' || inputFormat === 'turtle' || inputFormat === 'ttl' || inputFormat === 'nt' || autoRdf) {
-    return parseRdfClauses(source, options);
-  }
   return parseClauses(source, options);
 }

package/lib/eyelang/{solver.mjs → solver.js}

@@ -1,8 +1,8 @@
 // Depth-first eyelang solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
-import { COMPOUND, Env, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.mjs';
-import { createDefaultRegistry } from './builtins/registry.mjs';
-import { selectClauseCandidates } from './program.mjs';
+import { COMPOUND, Env, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { createDefaultRegistry } from './builtins/registry.js';
+import { selectClauseCandidates } from './program.js';
 
 let freshCounter = 0;
 
@@ -234,4 +234,4 @@ function importResolved(term, env) {
 }
 
 // Avoid circular import surprises in older Node loaders.
-import * as termModuleCache from './term.mjs';
+import * as termModuleCache from './term.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.33.1",
+  "version": "1.33.3",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -87,8 +87,8 @@
     "./package.json": "./package.json",
     "./eyelang": {
       "types": "./eyelang.d.ts",
-      "import": "./lib/eyelang/index.mjs",
-      "default": "./lib/eyelang/index.mjs"
+      "import": "./lib/eyelang/index.js",
+      "default": "./lib/eyelang/index.js"
     }
   },
   "typesVersions": {

package/test/eyelang/run-conformance.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { Program, run } from '../../lib/eyelang/index.mjs';
+import { Program, run } from '../../lib/eyelang/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.mjs';
 

package/test/eyelang/run-examples.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { Program, run } from '../../lib/eyelang/index.mjs';
+import { Program, run } from '../../lib/eyelang/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.mjs';
 
@@ -54,7 +54,7 @@ export function runExamples(reporter = new TestReporter()) {
 
 
 function exampleIsRunnable(name) {
-  return name.endsWith('.pl') || name.endsWith('.n3') || name.endsWith('.ttl') || name.endsWith('.nt');
+  return name.endsWith('.pl');
 }
 
 function runExample(name) {
@@ -79,7 +79,6 @@ function runProgramExample(programFile, filename, options) {
     const program = Program.parseSources([{ text, filename }], {
       sourceMetadata: options.proof,
       markRecursive: options.proof,
-      inputFormat: 'auto',
     });
     return run(program, options).stdout;
   } finally {

package/test/eyelang/run-regression.mjs

@@ -30,12 +30,11 @@ import {
   unify,
   variantTerms,
   parseProgramText,
-  rdfToEyelang,
-} from '../../lib/eyelang/index.mjs';
-import { parseGoalText } from '../../lib/eyelang/parser.mjs';
-import { selectClauseCandidates } from '../../lib/eyelang/program.mjs';
+} from '../../lib/eyelang/index.js';
+import { parseGoalText } from '../../lib/eyelang/parser.js';
+import { selectClauseCandidates } from '../../lib/eyelang/program.js';
 import { TestReporter, isMainModule } from './test-style.mjs';
-import { hashHex } from '../../lib/eyelang/hash.mjs';
+import { hashHex } from '../../lib/eyelang/hash.js';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..', '..');
@@ -207,66 +206,6 @@ why(
       },
     },
 
-    {
-      name: 'RDF 1.2 Turtle annotations lower to rdf/3 facts',
-      run: () => {
-        const source = 'VERSION "1.2"\nPREFIX : <http://example.com/>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n:alice :name "Alice" ~ :t {| :statedBy :bob ; :recorded "2021-07-07"^^xsd:date |} .\n';
-        const actual = rdfToEyelang(source, { materializeRdf: false });
-        assertEqual(actual, [
-          'rdf(iri("http://example.com/alice"), iri("http://example.com/name"), literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", "")).\n',
-          'rdf(iri("http://example.com/t"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies"), triple(iri("http://example.com/alice"), iri("http://example.com/name"), literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", ""))).\n',
-          'rdf(iri("http://example.com/t"), iri("http://example.com/statedBy"), iri("http://example.com/bob")).\n',
-          'rdf(iri("http://example.com/t"), iri("http://example.com/recorded"), literal("2021-07-07", iri("http://www.w3.org/2001/XMLSchema#date"), "", "")).\n',
-        ].join(''), 'rdfToEyelang');
-      },
-    },
-    {
-      name: 'Notation3 rules materialize derived RDF triples',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n{ ?x :parent ?y . } => { ?x :related ?y . } .\n:alice :parent :bob .\n';
-        const actual = run(source, { inputFormat: 'n3' }).stdout;
-        assertEqual(actual, 'rdf(iri("http://example.com/alice"), iri("http://example.com/related"), iri("http://example.com/bob")).\n', 'stdout');
-      },
-    },
-    {
-      name: '--rdf reads RDF 1.2 / N3 compatibility input',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n{ ?x :parent ?y . } => { ?x :related ?y . } .\n:alice :parent :bob .\n';
-        const result = runCli(['--rdf', '-'], { input: source });
-        assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, 'rdf(iri("http://example.com/alice"), iri("http://example.com/related"), iri("http://example.com/bob")).\n', 'stdout');
-        assertEqual(result.stderr, '', 'stderr');
-      },
-    },
-
-    {
-      name: 'Notation3 <= rules and builtins materialize derived RDF triples',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n@prefix math: <http://www.w3.org/2000/10/swap/math#> .\n{ ?x :ok true . } <= { (2 3) math:sum ?n . ?n math:equalTo 5 . ?x :seed true . } .\n:case :seed true .\n';
-        const actual = run(source, { inputFormat: 'n3' }).stdout;
-        assertEqual(actual, 'rdf(iri("http://example.com/case"), iri("http://example.com/ok"), literal("true", iri("http://www.w3.org/2001/XMLSchema#boolean"), "", "")).\n', 'stdout');
-      },
-    },
-
-    {
-      name: 'bundled RDF 1.2 / N3 examples match golden output',
-      run: () => {
-        const dir = path.join(packageRoot, 'examples', 'eyelang');
-        const files = fs.readdirSync(dir)
-          .filter((name) => name.endsWith('.n3') || name.endsWith('.ttl'))
-          .sort();
-        assertEqual(files.length > 0, true, 'rdf example files exist');
-        for (const name of files) {
-          const result = runCli([path.join('examples', 'eyelang', name)]);
-          assertEqual(result.status, 0, `${name} exit status`);
-          assertEqual(result.stderr, '', `${name} stderr`);
-          const expected = fs.readFileSync(path.join(dir, 'output', name), 'utf8');
-          assertEqual(result.stdout, expected, `${name} stdout`);
-        }
-      },
-    },
-
-
     {
       name: '--proof enables materialization explanations',
       run: () => {

package/test/eyelang/test-style.mjs

@@ -1,17 +1,20 @@
 // Shared test output helpers.
 // The runners use this small reporter so individual suites and `npm test` share
-// one compact, Eyesharl-like style with a continuous grey test number.
+// one compact Eyeling-style layout: colored OK/FAIL, sequence number, test description, and dimmed timing.
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
-const useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR == null;
+const useColor = process.env.NO_COLOR == null && (
+  Boolean(process.stdout.isTTY) ||
+  Boolean(process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0')
+);
 
 export const colors = {
   green: useColor ? '\x1b[32m' : '',
   red: useColor ? '\x1b[31m' : '',
   yellow: useColor ? '\x1b[33m' : '',
-  grey: useColor ? '\x1b[90m' : '',
+  dim: useColor ? '\x1b[2m' : '',
   reset: useColor ? '\x1b[0m' : '',
 };
 
@@ -45,7 +48,7 @@ export class TestReporter {
     const total = this.total - this.currentSection.totalAtStart;
     const ms = nowMs() - this.currentSection.startedAt;
     const suite = label ?? defaultSectionLabel(this.currentSection.name);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.grey}(${ms} ms)${colors.reset}\n`);
+    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 
   test(name, run) {
@@ -57,10 +60,10 @@ export class TestReporter {
       run();
       const ms = nowMs() - startedAt;
       this.ok++;
-      this.stdout.write(`${colors.grey}${nr}${colors.reset} ${colors.green}OK${colors.reset} ${name} ${colors.grey}(${ms} ms)${colors.reset}\n`);
+      this.stdout.write(`${colors.green}OK${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
     } catch (error) {
       const ms = nowMs() - startedAt;
-      this.stderr.write(`${colors.grey}${nr}${colors.reset} ${colors.red}FAIL${colors.reset} ${name} ${colors.grey}(${ms} ms)${colors.reset}\n`);
+      this.stderr.write(`${colors.red}FAIL${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
       this.stderr.write(`${error?.stack ?? String(error)}\n`);
       throw error;
     }
@@ -69,7 +72,7 @@ export class TestReporter {
   totalLine() {
     const ms = nowMs() - this.startedAt;
     this.stdout.write(`\n${colors.yellow}== Total${colors.reset}\n`);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests passed ${colors.grey}(${ms} ms)${colors.reset}\n`);
+    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 }
 

package/test/eyelang.test.js

@@ -47,7 +47,7 @@ out(X) :- in(X).
   assert.match(directCli.stdout, /ancestor\(jan, emma\)\./);
 
   // Sanity check the ESM file URL too; this catches nested package type regressions.
-  const esm = await import(pathToFileURL(`${process.cwd()}/lib/eyelang/index.mjs`).href);
+  const esm = await import(pathToFileURL(`${process.cwd()}/lib/eyelang/index.js`).href);
   assert.equal(typeof esm.Program, 'function');
 
   pass(1, 'eyelang second-engine integration passed', Date.now() - startedAt);