eyelang 0.5.1 → 0.5.2

package/index.d.ts

@@ -1,12 +1,12 @@
-export interface EyeLangStats {
+export interface EyelangStats {
   [key: string]: number;
 }
 
-export interface EyeLangRunOptions {
+export interface EyelangRunOptions {
   /** A host-supplied goal, expressed as Prolog text or a parsed term. */
-  goal?: string | EyeLangTerm;
+  goal?: string | EyelangTerm;
   /** Host-supplied goals, executed in order. */
-  goals?: Array<string | EyeLangTerm>;
+  goals?: Array<string | EyelangTerm>;
   proof?: boolean;
   why?: boolean;
   explain?: boolean;
@@ -23,9 +23,9 @@ export interface EyeLangRunOptions {
   [key: string]: unknown;
 }
 
-export interface EyeLangRunResult {
+export interface EyelangRunResult {
   stdout: string;
-  stats: EyeLangStats;
+  stats: EyelangStats;
   haltCode: number | null;
 }
 
@@ -37,25 +37,25 @@ export class StreamManager {
   currentOutput: number;
 }
 
-export interface EyeLangSourcePart {
+export interface EyelangSourcePart {
   text?: string;
   source?: string;
   filename?: string;
   baseDir?: string;
 }
 
-export interface EyeLangClause {
-  head: EyeLangTerm;
-  body: EyeLangTerm[];
+export interface EyelangClause {
+  head: EyelangTerm;
+  body: EyelangTerm[];
   index?: number;
   filename?: string;
   clauseNumber?: number;
 }
 
-export interface EyeLangPredicateGroup {
+export interface EyelangPredicateGroup {
   name: string;
   arity: number;
-  clauses: EyeLangClause[];
+  clauses: EyelangClause[];
   argIndexes: unknown[];
   demandIndexes: Map<string, unknown>;
   rejectedDemandIndexes: Set<string>;
@@ -65,42 +65,42 @@ export interface EyeLangPredicateGroup {
   negationStratum: number | null;
 }
 
-export type EyeLangTerm = Term | { type: string; name: string; args?: EyeLangTerm[]; arity?: number };
+export type EyelangTerm = Term | { type: string; name: string; args?: EyelangTerm[]; arity?: number };
 
 export class Term {
-  constructor(type: string, name?: unknown, args?: EyeLangTerm[]);
+  constructor(type: string, name?: unknown, args?: EyelangTerm[]);
   type: string;
   name: string;
-  args: EyeLangTerm[];
+  args: EyelangTerm[];
   get arity(): number;
 }
 
 export class Env {
-  constructor(bindings?: Iterable<readonly [string, EyeLangTerm]> | null);
-  bindings: Map<string, EyeLangTerm>;
+  constructor(bindings?: Iterable<readonly [string, EyelangTerm]> | null);
+  bindings: Map<string, EyelangTerm>;
   clone(): Env;
   has(name: string): boolean;
-  get(name: string): EyeLangTerm | undefined;
-  bind(name: string, term: EyeLangTerm): void;
+  get(name: string): EyelangTerm | undefined;
+  bind(name: string, term: EyelangTerm): void;
 }
 
 export class Program {
-  constructor(clauses?: EyeLangClause[], options?: EyeLangRunOptions);
-  clauses: EyeLangClause[];
-  groups: Map<string, EyeLangPredicateGroup>;
+  constructor(clauses?: EyelangClause[], options?: EyelangRunOptions);
+  clauses: EyelangClause[];
+  groups: Map<string, EyelangPredicateGroup>;
   negationDependencies: Array<{ from: string; to: string; negative: boolean }>;
   negationStratificationErrors: Array<{ from: string; to: string }>;
   stratifiedNegation: boolean;
-  static parse(source: string, options?: EyeLangRunOptions): Program;
-  static parseSources(sources?: Array<string | EyeLangSourcePart>, options?: EyeLangRunOptions): Program;
-  makeGroup(name: string, arity: number): EyeLangPredicateGroup;
-  indexClause(clause: EyeLangClause): void;
-  findGroup(name: string, arity: number): EyeLangPredicateGroup | null;
+  static parse(source: string, options?: EyelangRunOptions): Program;
+  static parseSources(sources?: Array<string | EyelangSourcePart>, options?: EyelangRunOptions): Program;
+  makeGroup(name: string, arity: number): EyelangPredicateGroup;
+  indexClause(clause: EyelangClause): void;
+  findGroup(name: string, arity: number): EyelangPredicateGroup | null;
   markRecursivePredicates(): void;
   analyzeNegationStratification(): Array<{ from: string; to: string }>;
   assertStratifiedNegation(): true;
   isStratifiedNegation(): boolean;
-  groupHasRule(group: EyeLangPredicateGroup): boolean;
+  groupHasRule(group: EyelangPredicateGroup): boolean;
   sourceFactLines(predicateKeys?: Set<string> | null): Set<string>;
 }
 
@@ -109,13 +109,13 @@ export interface BuiltinDefinition {
   arity: number;
   handler: BuiltinHandler;
   deterministic: boolean;
-  ready: ((goal: EyeLangTerm, env: Env) => boolean) | null;
+  ready: ((goal: EyelangTerm, env: Env) => boolean) | null;
   fallbackWhenNotReady: boolean;
-  shouldUse: ((context: { solver: Solver; goal: EyeLangTerm; env: Env }) => boolean) | null;
+  shouldUse: ((context: { solver: Solver; goal: EyelangTerm; env: Env }) => boolean) | null;
   eyeLangLibrary: boolean;
 }
 
-export type BuiltinHandler = (context: { solver: Solver; goal: EyeLangTerm; env: Env }) => Iterable<Env>;
+export type BuiltinHandler = (context: { solver: Solver; goal: EyelangTerm; env: Env }) => Iterable<Env>;
 
 export class BuiltinRegistry {
   constructor();
@@ -126,7 +126,7 @@ export class BuiltinRegistry {
 }
 
 export class Solver {
-  constructor(program: Program, options?: EyeLangRunOptions);
+  constructor(program: Program, options?: EyelangRunOptions);
   program: Program;
   registry: BuiltinRegistry;
   maxDepth: number;
@@ -134,10 +134,10 @@ export class Solver {
   solutionsSeen: number;
   active: unknown[];
   memo: Map<string, unknown>;
-  stats: EyeLangStats;
+  stats: EyelangStats;
   cloneForInnerGoal(solutionLimit?: number): Solver;
-  solve(goals: EyeLangTerm | EyeLangTerm[], env?: Env, depth?: number): Iterable<Env>;
-  activeVariant(goal: EyeLangTerm, env: Env): boolean;
+  solve(goals: EyelangTerm | EyelangTerm[], env?: Env, depth?: number): Iterable<Env>;
+  activeVariant(goal: EyelangTerm, env: Env): boolean;
 }
 
 export const VAR: 'var';
@@ -151,44 +151,44 @@ export function atom(name: string): Term;
 export function stringTerm(value: string): Term;
 export function numberTerm(value: string | number): Term;
 /** Construct a compound term; an empty argument list is canonicalized to atom(name). */
-export function compound(name: string, args?: EyeLangTerm[]): Term;
+export function compound(name: string, args?: EyelangTerm[]): Term;
 export function emptyList(): Term;
-export function cons(head: EyeLangTerm, tail: EyeLangTerm): Term;
-export function deref(term: EyeLangTerm, env: Env): EyeLangTerm;
-export function isScalar(term: EyeLangTerm | null | undefined): boolean;
-export function isEmptyList(term: EyeLangTerm | null | undefined): boolean;
-export function isCons(term: EyeLangTerm | null | undefined): boolean;
-export function isConjunction(term: EyeLangTerm | null | undefined): boolean;
-export function unify(left: EyeLangTerm, right: EyeLangTerm, env: Env): boolean;
-export function cloneTerm(term: EyeLangTerm): Term;
-export function freshTerm(term: EyeLangTerm, suffix: string | number): Term;
-export function copyResolved(term: EyeLangTerm, env: Env): Term;
-export function termIsGround(term: EyeLangTerm, env?: Env): boolean;
-export function termToString(term: EyeLangTerm, env?: Env, quoteStrings?: boolean): string;
-export function lexicalValue(term: EyeLangTerm, env: Env): string | null;
-export function properListItems(list: EyeLangTerm, env: Env): EyeLangTerm[] | null;
-export function listFromItems(items: EyeLangTerm[], start?: number, end?: number, tail?: EyeLangTerm): Term;
-export function flattenConjunction(goal: EyeLangTerm): EyeLangTerm[];
-export function termSignature(term: EyeLangTerm | null | undefined): string | null;
-export function variantTerms(left: EyeLangTerm, leftEnv: Env, right: EyeLangTerm, rightEnv: Env, pairs?: Map<string, string>, reverse?: Map<string, string>): boolean;
-export function compareTerms(left: EyeLangTerm, right: EyeLangTerm): number;
+export function cons(head: EyelangTerm, tail: EyelangTerm): Term;
+export function deref(term: EyelangTerm, env: Env): EyelangTerm;
+export function isScalar(term: EyelangTerm | null | undefined): boolean;
+export function isEmptyList(term: EyelangTerm | null | undefined): boolean;
+export function isCons(term: EyelangTerm | null | undefined): boolean;
+export function isConjunction(term: EyelangTerm | null | undefined): boolean;
+export function unify(left: EyelangTerm, right: EyelangTerm, env: Env): boolean;
+export function cloneTerm(term: EyelangTerm): Term;
+export function freshTerm(term: EyelangTerm, suffix: string | number): Term;
+export function copyResolved(term: EyelangTerm, env: Env): Term;
+export function termIsGround(term: EyelangTerm, env?: Env): boolean;
+export function termToString(term: EyelangTerm, env?: Env, quoteStrings?: boolean): string;
+export function lexicalValue(term: EyelangTerm, env: Env): string | null;
+export function properListItems(list: EyelangTerm, env: Env): EyelangTerm[] | null;
+export function listFromItems(items: EyelangTerm[], start?: number, end?: number, tail?: EyelangTerm): Term;
+export function flattenConjunction(goal: EyelangTerm): EyelangTerm[];
+export function termSignature(term: EyelangTerm | null | undefined): string | null;
+export function variantTerms(left: EyelangTerm, leftEnv: Env, right: EyelangTerm, rightEnv: Env, pairs?: Map<string, string>, reverse?: Map<string, string>): boolean;
+export function compareTerms(left: EyelangTerm, right: EyelangTerm): number;
 export function isDecimalInteger(text: string | null | undefined): boolean;
 export function compareIntegerText(left: string, right: string): number;
 export function parseFiniteNumber(text: string | null | undefined): number | null;
 export function numberTextFromDouble(value: number): string | null;
 export function compareNumberText(left: string, right: string): number;
 
-export function makeProgram(source: string, options?: EyeLangRunOptions): Program;
-export function parseClauses(source: string, options?: EyeLangRunOptions): EyeLangClause[];
-export function parseProgramText(source: string, options?: EyeLangRunOptions): EyeLangClause[];
-export function parseGoalText(source: string): EyeLangTerm;
+export function makeProgram(source: string, options?: EyelangRunOptions): Program;
+export function parseClauses(source: string, options?: EyelangRunOptions): EyelangClause[];
+export function parseProgramText(source: string, options?: EyelangRunOptions): EyelangClause[];
+export function parseGoalText(source: string): EyelangTerm;
 export function createDefaultRegistry(): BuiltinRegistry;
-export function createEyeLangRegistry(): BuiltinRegistry;
+export function createEyelangRegistry(): BuiltinRegistry;
 export function getDefaultRegistry(): BuiltinRegistry;
-export function getEyeLangRegistry(): BuiltinRegistry;
+export function getEyelangRegistry(): BuiltinRegistry;
 export class PrologError extends Error {
   formal: string;
-  culprit: EyeLangTerm | null;
+  culprit: EyelangTerm | null;
 }
 
 export class HaltSignal extends Error {
@@ -196,10 +196,10 @@ export class HaltSignal extends Error {
   code: number;
   constructor(code?: number);
 }
-export function run(source: string | Program, options?: EyeLangRunOptions): EyeLangRunResult;
-export function whyProof(program: Program, goal: EyeLangTerm, options?: EyeLangRunOptions): { ok: boolean; text: string };
-export function whyNoProof(goal: EyeLangTerm): string;
-export function explainProof(program: Program, goal: EyeLangTerm, options?: EyeLangRunOptions): { ok: boolean; text: string };
+export function run(source: string | Program, options?: EyelangRunOptions): EyelangRunResult;
+export function whyProof(program: Program, goal: EyelangTerm, options?: EyelangRunOptions): { ok: boolean; text: string };
+export function whyNoProof(goal: EyelangTerm): string;
+export function explainProof(program: Program, goal: EyelangTerm, options?: EyelangRunOptions): { ok: boolean; text: string };
 
 declare const eyelang: {
   VAR: typeof VAR;
@@ -247,9 +247,9 @@ declare const eyelang: {
   parseClauses: typeof parseClauses;
   parseProgramText: typeof parseProgramText;
   createDefaultRegistry: typeof createDefaultRegistry;
-  createEyeLangRegistry: typeof createEyeLangRegistry;
+  createEyelangRegistry: typeof createEyelangRegistry;
   getDefaultRegistry: typeof getDefaultRegistry;
-  getEyeLangRegistry: typeof getEyeLangRegistry;
+  getEyelangRegistry: typeof getEyelangRegistry;
   run: typeof run;
   whyProof: typeof whyProof;
   whyNoProof: typeof whyNoProof;

package/index.js

@@ -1,4 +1,4 @@
-// Public EyeLang JavaScript API.
+// Public Eyelang JavaScript API.
 export * from './src/index.js';
 import * as eyelang from './src/index.js';
 export default eyelang;

package/package.json

@@ -3,8 +3,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.1",
-  "description": "EyeLang turns facts and rules into answers and proofs.",
+  "version": "0.5.2",
+  "description": "Eyelang turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/playground.html

@@ -4,7 +4,7 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="icon" type="image/png" href="eyelang-logo.png">
-  <title>EyeLang Playground</title>
+  <title>Eyelang Playground</title>
   <style>
     :root {
       color-scheme: light dark;
@@ -353,8 +353,8 @@
 </head>
 <body>
   <header>
-    <h1>The EyeLang Playground</h1>
-    <p>Run EyeLang programs in your browser with syntax coloring, examples, proofs, and shareable editor links.</p>
+    <h1>The Eyelang Playground</h1>
+    <p>Run Eyelang programs in your browser with syntax coloring, examples, proofs, and shareable editor links.</p>
   </header>
 
   <main>
@@ -371,7 +371,7 @@
       <details>
         <summary id="advanced-heading">⚙ Advanced configuration</summary>
         <div class="toolbar" aria-label="URL loader">
-          <label for="source-url">Load EyeLang from URL</label>
+          <label for="source-url">Load Eyelang from URL</label>
           <input id="source-url" type="url" placeholder="https://example.org/program.pl">
           <button id="load-url" type="button">Load from URL</button>
         </div>
@@ -385,7 +385,7 @@
           <label><input id="stats" type="checkbox"> Show stats</label>
         </div>
         <div class="panel-body">
-          <p class="hint">Enter any EyeLang file URL and click “Load from URL”. Background knowledge is prepended when the program runs.</p>
+          <p class="hint">Enter any Eyelang file URL and click “Load from URL”. Background knowledge is prepended when the program runs.</p>
         </div>
       </details>
     </section>
@@ -393,14 +393,14 @@
     <section aria-labelledby="editor-heading">
       <div class="editor-shell">
         <div class="editor-label">
-          <strong id="editor-heading">Editable EyeLang program</strong>
+          <strong id="editor-heading">Editable Eyelang program</strong>
           <span id="source-name" class="hint">custom program</span>
         </div>
         <div class="editor">
           <div id="line-numbers" class="line-numbers" aria-hidden="true"><div class="line-numbers-inner"></div></div>
           <div id="error-line-marker" class="error-line-marker" aria-hidden="true"></div>
           <pre id="highlight" aria-hidden="true"><code></code></pre>
-          <textarea id="source" spellcheck="false" autocapitalize="off" autocomplete="off" aria-label="Editable EyeLang source"></textarea>
+          <textarea id="source" spellcheck="false" autocapitalize="off" autocomplete="off" aria-label="Editable Eyelang source"></textarea>
         </div>
       </div>
       <div class="toolbar button-row">
@@ -432,7 +432,7 @@
   </main>
 
   <footer>
-    Powered by <a href="https://github.com/eyereasoner/eyelang">EyeLang</a>.
+    Powered by <a href="https://github.com/eyereasoner/eyelang">Eyelang</a>.
   </footer>
 
   <script type="module">
@@ -953,7 +953,7 @@
       clearSyntaxError();
       output.textContent = '';
       elapsed.textContent = 'Running…';
-      setStatus('Running EyeLang…');
+      setStatus('Running Eyelang…');
       runButton.disabled = true;
       stopButton.disabled = false;
 
@@ -1150,7 +1150,7 @@
             'Content-Type': 'application/json',
           },
           body: JSON.stringify({
-            description: 'EyeLang playground share',
+            description: 'Eyelang playground share',
             public: false,
             files,
           }),

package/src/cli.js

@@ -1,4 +1,4 @@
-// Command-line interface for EyeLang.
+// Command-line interface for Eyelang.
 // It loads programs from files, URLs, or stdin, then runs requested goals.
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -137,7 +137,7 @@ async function runDefault(engine, program, options) {
   const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
   const facts = program.sourceFactLines(queriedKeys);
   const lines = new Set();
-  const registry = engine.getEyeLangRegistry();
+  const registry = engine.getEyelangRegistry();
   const explanation = options.proof ? await loadExplanation() : null;
   const solver = new engine.Solver(program, {
     registry,
@@ -181,8 +181,8 @@ Usage:
   eyelang [options] [file-or-url.pl|- ...]
 
 Input:
-  file-or-url.pl        Read an EyeLang program from a local file or http(s) URL.
-  -                     Read an EyeLang program from standard input.
+  file-or-url.pl        Read an Eyelang program from a local file or http(s) URL.
+  -                     Read an Eyelang program from standard input.
 
 Options:
   -h, --help            Show this help text and exit.

package/src/explain.js

@@ -1,15 +1,15 @@
-// EyeLang proof output helpers.
+// Eyelang proof output helpers.
 // The explanation printer replays a successful goal against the program and emits
-// ordinary EyeLang facts with nested proof terms.  Explanations are therefore both
+// ordinary Eyelang facts with nested proof terms.  Explanations are therefore both
 // human-readable and machine-readable.
 import { ATOM, COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
 import { selectClauseCandidates } from './program.js';
-import { getEyeLangRegistry } from './library.js';
+import { getEyelangRegistry } from './library.js';
 import { Solver, nextFreshId } from './solver.js';
 
 export function whyProof(program, goal, options = {}) {
   const maxDepth = options.maxDepth ?? 256;
-  const registry = options.registry ?? getEyeLangRegistry();
+  const registry = options.registry ?? getEyelangRegistry();
   const env = options.env ?? new Env();
   for (const proof of proveGoalAll(program, goal, env, 0, maxDepth, registry, [])) {
     return { ok: true, text: renderWhyFacts(goal, proof.node, proof.env) };

package/src/index.js

@@ -12,8 +12,8 @@ export {
   PrologError,
 } from './iso.js';
 export {
-  createEyeLangRegistry,
-  getEyeLangRegistry,
+  createEyelangRegistry,
+  getEyelangRegistry,
 } from './library.js';
 export { StreamManager } from './io.js';
 
@@ -22,14 +22,14 @@ import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { whyNoProof, whyProof } from './explain.js';
 import { HaltSignal, PrologError } from './iso.js';
-import { getEyeLangRegistry } from './library.js';
+import { getEyelangRegistry } from './library.js';
 import { parseGoalText } from './parser.js';
 
 export function run(source, options = {}) {
   const includeWhy = options.proof === true || options.why === true || options.explain === true;
   const parseOptions = { ...options, sourceMetadata: includeWhy };
   let program = source instanceof Program ? source : Program.parse(source, parseOptions);
-  const runOptions = options.registry ? options : { ...options, registry: getEyeLangRegistry() };
+  const runOptions = options.registry ? options : { ...options, registry: getEyelangRegistry() };
   const output = [];
   const solver = new Solver(program, {
     ...runOptions,

package/src/iso.js

@@ -1,4 +1,4 @@
-// Built-ins in EyeLang's documented ISO compatibility profile. This is a
+// Built-ins in Eyelang's documented ISO compatibility profile. This is a
 // deliberately incomplete profile, not the complete standard environment.
 import {
   ATOM, COMPOUND, NUMBER, STRING, VAR, Env,

package/src/library.js

@@ -1,4 +1,4 @@
-// EyeLang library implemented entirely as native JavaScript builtins.
+// Eyelang library implemented entirely as native JavaScript builtins.
 // The single registry is shared by Node, embedders, and the browser playground.
 import {
   ATOM,
@@ -34,7 +34,7 @@ import {
 } from './iso.js';
 
 // Numeric builtins for integer-preserving arithmetic, floating point functions, comparisons, and ranges.
-// The code keeps BigInt paths where possible so large EyeLang integers remain exact.
+// The code keeps BigInt paths where possible so large Eyelang integers remain exact.
 
 const unaryNames = ['tan', 'asin', 'acos'];
 const binaryNames = ['atan2'];
@@ -461,7 +461,7 @@ function contextFromGroups(groups) {
 function numericText(text) {
   return isDecimalInteger(text) || parseFiniteNumber(text) != null;
 }
-// Native EyeLang library relations.
+// Native Eyelang library relations.
 // These predicates used to be parsed from bundled Prolog source. Keeping them
 // in the builtin registry removes startup parsing, avoids browser module/cache
 // duplication, and gives the hot list/aggregation paths direct JavaScript
@@ -998,7 +998,7 @@ function integerArgument(term, env) {
   return BigInt(resolved.name);
 }
 
-export function createEyeLangRegistry() {
+export function createEyelangRegistry() {
   const registry = new BuiltinRegistry();
   registry.eyeLangLibrary = true;
   for (const mod of [
@@ -1012,14 +1012,14 @@ export function createEyeLangRegistry() {
   }
   for (const definition of registry.defs.values()) definition.eyeLangLibrary = true;
   // ISO definitions take precedence where names overlap and remain identifiable
-  // as ISO rather than EyeLang-library predicates.
+  // as ISO rather than Eyelang-library predicates.
   isoBuiltins.register(registry);
   return registry;
 }
 
 let eyeLangRegistry = null;
 
-export function getEyeLangRegistry() {
-  if (eyeLangRegistry == null) eyeLangRegistry = createEyeLangRegistry();
+export function getEyelangRegistry() {
+  if (eyeLangRegistry == null) eyeLangRegistry = createEyelangRegistry();
   return eyeLangRegistry;
 }

package/src/parser.js

@@ -1,4 +1,4 @@
-// Tokenizer and recursive-descent parser for the EyeLang source language.
+// 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.js';
 

package/src/playground-worker.js

@@ -2,9 +2,9 @@
 // Keep this module free of Node-only imports: it is fetched directly by the
 // browser and is also exercised by test/run-playground.mjs.
 import { run } from './index.js?playground=20260803c';
-import { createEyeLangRegistry } from './library.js?playground=20260803c';
+import { createEyelangRegistry } from './library.js?playground=20260803c';
 
-const registry = createEyeLangRegistry();
+const registry = createEyelangRegistry();
 
 export function executePlaygroundRequest(data, now = defaultNow) {
   const started = now();

package/src/solver.js

@@ -1,11 +1,11 @@
-// Depth-first EyeLang solver with builtin dispatch, memoization, and guarded recursion handling.
+// 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, compound, copyResolved, deref, flattenConjunction, freshTerm,
   numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variantTerms,
 } from './term.js';
 import { PrologError } from './iso.js';
-import { getEyeLangRegistry } from './library.js';
+import { getEyelangRegistry } from './library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program.js';
 import { StreamManager } from './io.js';
 
@@ -17,7 +17,7 @@ export function nextFreshId() {
 
 export class Solver {
   constructor(program, options = {}) {
-    this.registry = options.registry ?? getEyeLangRegistry();
+    this.registry = options.registry ?? getEyelangRegistry();
     this.program = program;
     this.mutableProgram = program.mutable === true;
     this.programRevision = this.program.revision ?? 0;
@@ -196,7 +196,7 @@ export class Solver {
           continue;
         }
 
-        // EyeLang normally solves left-to-right, but ready deterministic builtins can
+        // Eyelang normally solves left-to-right, but ready deterministic builtins can
         // be run early as pure filters. Stop at internal sentinels so rule-body
         // active guards are released before the caller's remaining goals are seen.
         const selectedIndex = selectReadyDeterministicBuiltin(goals, env, this.registry);

package/src/term.js

@@ -187,7 +187,7 @@ function occurs(variableName, term, env) {
 
 export function unify(left, right, env) {
   // Iterative unification avoids deep JavaScript recursion on long lists or
-  // deeply nested compounds. The occurs check gives EyeLang finite-tree
+  // deeply nested compounds. The occurs check gives Eyelang finite-tree
   // unification: a variable cannot be bound to a term containing itself.
   // Bindings are written into the supplied Env.
   const stack = [[left, right]];

package/test/conformance/README.md

@@ -1,27 +1,27 @@
-# EyeLang profile conformance suite
+# Eyelang profile conformance suite
 
-This directory contains executable tests for the EyeLang implementation and
+This directory contains executable tests for the Eyelang implementation and
 reasoner.
-[*The Art of EyeLang*](../../the-art-of-eyelang.md) is the reference for the
+[*The Art of Eyelang*](../../the-art-of-eyelang.md) is the reference for the
 supported ISO Prolog profile, built-ins, extensions, and reasoner behavior.
 
 The suite is intentionally file-based. Exact standard output, errors, warnings,
 and proof output test the behavior of the JavaScript implementation.
 
-“Conformance” here means conformance to EyeLang's documented ISO compatibility
+“Conformance” here means conformance to Eyelang's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
 predicate indicators listed in Appendix B of the book across the supported
 ISO/IEC 13211-1:1995 standard families. This suite is still not an independent certification of
 every processor requirement, lexical edge, option combination, or prescribed
 error precedence. Cases under `iso/` identify standards-derived behavior;
-other directories cover EyeLang host contracts and extensions.
+other directories cover Eyelang host contracts and extensions.
 
 All conformance files live under topic directories such as `arithmetic/`, `lists/`, `syntax/`, or `variables/`; new top-level numbered files should not be added. The report uses those directories as coverage categories.
 
 A normal positive case consists of:
 
 - `conformance/cases/<name>.pl` — input program;
-- `conformance/expected/<name>.pl` — exact expected standard output, stored as EyeLang-readable facts.
+- `conformance/expected/<name>.pl` — exact expected standard output, stored as Eyelang-readable facts.
 
 Expected-error cases consist of:
 

package/test/conformance/THIRD_PARTY.md

@@ -5,7 +5,7 @@
 Selected standard term, atom, character, collection, control, and conversion
 cases under `iso/` are adapted from the `tests/prolog` backend Prolog conformance suite in
 [Logtalk](https://github.com/LogtalkDotOrg/logtalk3). Each adapted file
-identifies its upstream test names. The cases were rewritten for EyeLang's
+identifies its upstream test names. The cases were rewritten for Eyelang's
 file-based query and exact-output harness and are therefore modified from the
 upstream files.
 
@@ -27,7 +27,7 @@ Selected lexical, term, numeric, comment, and operator cases under `iso/` are
 adapted from `tests-pl/iso-conformity-tests.pl` in
 [Scryer Prolog](https://github.com/mthom/scryer-prolog). Each adapted file
 identifies the corresponding upstream test numbers. The cases were rewritten
-for EyeLang's file-based query and exact-output harness.
+for Eyelang's file-based query and exact-output harness.
 
 BSD 3-Clause License
 
@@ -64,7 +64,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 Selected standard-core cases under `iso/` are adapted from the numbered tests
 in [`tests/tests`](https://github.com/trealla-prolog/trealla/tree/main/tests/tests)
 in Trealla Prolog. Each adapted file identifies its upstream test file. The
-cases were rewritten for EyeLang's query and exact-output harness.
+cases were rewritten for Eyelang's query and exact-output harness.
 
 MIT License
 
@@ -95,7 +95,7 @@ Selected standard-core operator and finite-tree unification cases under `iso/`
 are adapted from `tests/core/test_op.pl` and
 `tests/core/test_occurs_check.pl` in
 [SWI-Prolog](https://github.com/SWI-Prolog/swipl-devel). Each adapted file
-identifies its upstream source. The cases were rewritten for EyeLang's query and
+identifies its upstream source. The cases were rewritten for Eyelang's query and
 exact-output harness.
 
 BSD 2-Clause License

package/test/conformance/cases/iso/logtalk_abolish.pl

@@ -1,5 +1,5 @@
 % Adapted from Logtalk iso_abolish_1_01 and eddbali_abolish_1_06.
-% Modified for EyeLang's conformance harness. See test/conformance/THIRD_PARTY.md.
+% Modified for Eyelang's conformance harness. See test/conformance/THIRD_PARTY.md.
 :- dynamic(foo/1).
 foo(a).
 %% goal: abolish_result

package/test/conformance/cases/iso/logtalk_arg_unification.pl

@@ -1,5 +1,5 @@
 % Adapted from Logtalk iso_arg_3_01 through 07, eddbali_arg_3_15, and
-% lgt_arg_3_17 through 19. Modified for EyeLang's conformance harness.
+% lgt_arg_3_17 through 19. Modified for Eyelang's conformance harness.
 % See test/conformance/THIRD_PARTY.md.
 %% goal: arg_results(X0, X1, X2, X3)