eyeling 1.34.4 → 1.34.6

package/README.md

@@ -23,7 +23,6 @@ Eyeling is characterized by:
 - **Streaming RDF Messages** — supports RDF Messages streams, enabling Eyeling to fit into streaming RDF pipelines.
 - **Node.js, npm, and browser use** — run it from the command line, call it from JavaScript, or use the browser-oriented bundle.
 - **RDF-JS interoperability** — use N3 text, RDF-JS quads, datasets, or Eyeling’s own AST-level API, with TypeScript declarations grounded in `@rdfjs/types`.
-- **Experimental eyelang engine** — run compact Prolog-style Horn clause programs alongside the N3 engine, giving Eyeling a second reasoning engine without mixing the internals.
 
 
 This README is the primary guide to using, extending, and maintaining Eyeling.
@@ -34,8 +33,6 @@ Eyeling is designed for people who want a small, inspectable reasoner that can r
 
 - [Playground](https://eyereasoner.github.io/eyeling/playground)
 - [Conformance report](https://codeberg.org/phochste/notation3tests/src/branch/main/reports/report.md)
-- [eyelang guide](docs/eyelang-guide.md)
-- [eyelang language reference](docs/eyelang-language-reference.md)
 
 ---
 
@@ -47,7 +44,6 @@ Eyeling is designed for people who want a small, inspectable reasoner that can r
 4. [Command-line interface](#command-line-interface)
 5. [JavaScript API](#javascript-api)
 6. [RDF-JS integration](#rdf-js-integration)
-7. [Eyelang second engine](#eyelang-second-engine)
 8. [RDF compatibility mode and RDF 1.2](#rdf-compatibility-mode-and-rdf-12)
 9. [RDF Message Logs](#rdf-message-logs)
 10. [Built-ins](#built-ins)
@@ -76,7 +72,6 @@ It accepts facts and rules written in N3-style syntax, computes the logical cons
 - a browser/worker API through `eyeling/browser`;
 - an RDF-JS adapter for applications that work with quads and data factories;
 - a streaming tool for RDF Message Logs;
-- an experimental host for the `eyelang` Prolog-style Horn clause engine.
 
 Eyeling is intentionally small and dependency-light. The source tree is organized as a miniature compiler and inference engine: lexer, parser, term model, rule normalization, built-ins, forward chaining, backward proving, printing, RDF-JS adapters, and CLI wiring.
 
@@ -139,18 +134,12 @@ For proof output:
 node eyeling.js --proof examples/socrates.n3
 ```
 
-Run an eyelang program through the second engine:
-
-```bash
-eyeling --engine eyelang examples/eyelang/ancestor.pl
-```
 
 Or from JavaScript:
 
 ```js
 const { reason } = require('eyeling');
 
-const output = reason({ engine: 'eyelang' }, `
   materialize(out, 1).
   in(done).
   out(X) :- in(X).
@@ -297,11 +286,6 @@ Process an RDF Message Log one message at a time:
 eyeling --rdf --stream-messages rules.n3 messages.trig
 ```
 
-Run an eyelang program through the bundled second engine:
-
-```bash
-eyeling --engine eyelang examples/eyelang/ancestor.pl
-```
 
 ### CLI options
 
@@ -309,7 +293,6 @@ eyeling --engine eyelang examples/eyelang/ancestor.pl
 |---|---|
 | `-a`, `--ast` | Print the parsed AST as JSON and exit. |
 | `--builtin <module.js>` | Load a custom N3 built-in module. Repeatable. |
-| `--engine <n3\|eyelang>` | Select the default N3 engine or route the remaining arguments to the eyelang engine. |
 | `-d`, `--deterministic-skolem` | Make `log:skolem` stable across reasoning runs. |
 | `-e`, `--enforce-https` | Rewrite `http://` IRIs to `https://` for log dereferencing built-ins. |
 | `-h`, `--help` | Show help and exit. |
@@ -323,7 +306,6 @@ eyeling --engine eyelang examples/eyelang/ancestor.pl
 | `-t`, `--stream` | Stream derived triples as soon as they are derived. |
 | `-v`, `--version` | Print the package version and exit. |
 
-When `--engine eyelang` is selected, the remaining arguments are handled by the eyelang CLI. Its supported options are `--help`, `--proof`, `--stats`, `--version`, and `--` to stop option parsing. See the [eyelang guide](docs/eyelang-guide.md) for examples.
 
 ### Output behavior
 
@@ -623,60 +605,6 @@ Use RDF-JS when you want Eyeling to sit inside a JavaScript RDF pipeline. Use ra
 
 ---
 
-## Eyelang second engine
-
-Eyeling can also host the experimental `eyelang` engine. This is deliberately a second engine, not a rewrite of the N3 engine. The package therefore has two eyes:
-
-- the default **N3 engine** for RDF/Notation3 reasoning;
-- the **eyelang engine** for compact Prolog-style Horn clause programs.
-
-Use the CLI option when running `.pl` programs:
-
-```bash
-eyeling --engine eyelang examples/eyelang/ancestor.pl
-```
-
-A paired example shows the same vulnerability-impact scenario in both engines:
-
-```bash
-eyeling examples/vulnerability-impact.n3
-eyeling --engine eyelang examples/eyelang/vulnerability-impact.pl
-```
-
-Use the CommonJS convenience API when the rest of your application already imports `eyeling`:
-
-```js
-const { reason, reasonEyelang } = require('eyeling');
-
-const program = `
-  materialize(out, 1).
-  in(done).
-  out(X) :- in(X).
-`;
-
-console.log(reason({ engine: 'eyelang' }, program));
-console.log(await reasonEyelang(program));
-```
-
-Use the subpath export for the full eyelang module API:
-
-```js
-import { run, Program, Solver } from 'eyeling/eyelang';
-
-const result = run(program);
-console.log(result.stdout);
-```
-
-The two engines intentionally keep separate parsers, term models, solvers, and built-ins. Shared package entry points, examples, documentation, and CLI routing make them convenient to use together while keeping their execution models inspectable.
-
-The [eyelang guide](docs/eyelang-guide.md) introduces the CLI, output model, examples, and testing workflow. The [eyelang language reference](docs/eyelang-language-reference.md) defines syntax, terms, clauses, built-ins, declarations, output, and conformance boundaries. Runnable examples live under `examples/eyelang/`. The embedded engine runtime stays under `lib/eyelang/`, while the conformance corpus and test runners live under `test/eyelang/` so runtime code and test assets stay separate:
-
-```bash
-npm run test:eyelang        # integration check plus eyelang corpus
-npm run test:eyelang:corpus # eyelang corpus only
-```
-
----
 
 ## RDF compatibility mode and RDF 1.2
 
@@ -817,20 +745,6 @@ Formula-aware built-ins make Eyeling useful for meta-reasoning. `log:includes`,
 
 `log:semantics`, `log:content`, and related built-ins may dereference sources. Use `--enforce-https` or `{ enforceHttps: true }` in environments where HTTP-to-HTTPS rewriting is required.
 
-### eyelang built-ins
-
-The eyelang engine has its own built-in registry under `lib/eyelang/builtins/`. These are separate from the N3 namespaces above and are called as ordinary eyelang predicates. See the [eyelang language reference](docs/eyelang-language-reference.md#9-standard-built-in-predicates) for the portable profile. The bundled implementation currently registers 80 name/arity entries across 78 predicate names:
-
-| Family | Count | Built-ins |
-|---|---:|---|
-| Core and host | 4 | `eq/2`, `neq/2`, `local_time/1`, `difference/3` |
-| Arithmetic, comparison, and generators | 29 | `neg/2`, `abs/2`, `sin/2`, `cos/2`, `tan/2`, `asin/2`, `acos/2`, `sqrt/2`, `floor/2`, `ceiling/2`, `trunc/2`, `rounded/2`, `exp/2`, `log/2`, `add/3`, `sub/3`, `mul/3`, `div/3`, `mod/3`, `min/3`, `max/3`, `pow/3`, `atan2/3`, `lt/2`, `gt/2`, `le/2`, `ge/2`, `between/3`, `smallest_divisor_from/3` |
-| Strings and conversions | 15 | `str_concat/3`, `contains/2`, `matches/2`, `matches/3`, `not_matches/2`, `split/3`, `join/3`, `substring/4`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2` |
-| Lists | 19 | `append/3`, `nth0/3`, `set_nth0/4`, `head/2`, `rest/2`, `last/2`, `take/3`, `drop/3`, `slice/4`, `member/2`, `select/3`, `not_member/2`, `reverse/2`, `length/2`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `sort/2` |
-| Aggregation | 5 | `findall/3`, `countall/2`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| Control | 3 | `not/1`, `once/1`, `forall/2` |
-| Context and terms | 5 | `holds/2`, `holds/3`, `functor/3`, `arg/3`, `compound_name_arguments/3` |
-| **Total** | **80** |  |
 
 ## Custom built-ins
 
@@ -1096,8 +1010,8 @@ Everything else should be treated as internal unless explicitly documented.
 ├── bin/                      CLI executable shim
 ├── lib/                      Source modules
 ├── dist/browser/             Browser bundle and ESM wrapper
-├── docs/                     Project documentation, including the eyelang guide and language reference
-├── examples/                 N3 examples, eyelang examples, RDF message inputs, and generated decks
+├── docs/                     Project documentation
+├── examples/                 N3 examples, RDF message inputs, and generated decks
 ├── spec/                     RDF 1.2 parser test adapter
 ├── test/                     API, built-in, store, example, package, playground, and stream tests
 ├── tools/                    Build tooling
@@ -1111,7 +1025,7 @@ The package publishes the source modules, tests, examples, bundled runtime, brow
 
 ## Examples guide
 
-The repository contains more than two hundred N3 examples under `examples/`, eyelang `.pl` examples under `examples/eyelang/`, RDF Message input files under `examples/input/`, and presentation-oriented Markdown decks under `examples/deck/`. See the [eyelang guide](docs/eyelang-guide.md#example-catalog) for the eyelang example catalog.
+The repository contains more than two hundred N3 examples under `examples/`, RDF Message input files under `examples/input/`, and presentation-oriented Markdown decks under `examples/deck/`.
 
 ### Good first examples
 
@@ -1122,7 +1036,6 @@ The repository contains more than two hundred N3 examples under `examples/`, eye
 | `examples/age.n3` | Literal propagation. |
 | `examples/family-cousins.n3` | Multi-hop relational inference. |
 | `examples/dijkstra.n3` | Graph/path reasoning. |
-| `examples/vulnerability-impact.n3` and `examples/eyelang/vulnerability-impact.pl` | Paired N3 and eyelang dependency-risk example. |
 | `examples/list-map.n3` | List processing. |
 | `examples/string-builtins-tests.n3` | String built-ins. |
 | `examples/math-builtins-tests.n3` | Numeric built-ins. |

package/bin/eyeling.cjs

@@ -1,62 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
+const bundle = require('../eyeling.js');
 
-function extractEngineArg(argv) {
-  const filtered = [];
-  let engine = null;
-  let endOptions = false;
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-
-    if (!endOptions && arg === '--') {
-      endOptions = true;
-      filtered.push(arg);
-    } else if (!endOptions && arg === '--engine') {
-      engine = argv[++i];
-      if (!engine) throw new Error('--engine needs a value');
-    } else if (!endOptions && arg.startsWith('--engine=')) {
-      engine = arg.slice('--engine='.length);
-    } else {
-      filtered.push(arg);
-    }
-  }
-
-  return { engine, argv: filtered };
+if (!bundle || typeof bundle.main !== 'function') {
+  throw new Error('Eyeling CLI bundle did not expose main()');
 }
 
-function normalizeEngineName(value) {
-  if (value == null || value === '') return 'n3';
-  const name = String(value).toLowerCase();
-  if (name === 'n3' || name === 'eyeling') return 'n3';
-  if (name === 'eyelang' || name === 'prolog' || name === 'horn') return 'eyelang';
-  throw new Error(`unknown Eyeling engine: ${value}`);
-}
-
-async function runEyelangCli(argv) {
-  const cliUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'eyelang', 'cli.js')).href;
-  const cli = await import(cliUrl);
-  await cli.main(argv);
-}
-
-const parsed = extractEngineArg(process.argv.slice(2));
-const engine = normalizeEngineName(parsed.engine);
-
-if (engine === 'eyelang') {
-  runEyelangCli(parsed.argv).catch((error) => {
-    console.error(`eyeling: ${error && error.message ? error.message : String(error)}`);
-    process.exit(1);
-  });
-} else {
-  const bundle = require('../eyeling.js');
-
-  if (!bundle || typeof bundle.main !== 'function') {
-    throw new Error('Eyeling CLI bundle did not expose main()');
-  }
-
-  process.argv = [process.argv[0], process.argv[1], ...parsed.argv];
-  bundle.main();
-}
+bundle.main();

package/dist/browser/eyeling.browser.js

@@ -6483,7 +6483,6 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/examples/context-schema-audit.n3

@@ -1,6 +1,6 @@
 # Context schema audit
 #
-# This is the N3 counterpart of the eyelang context-schema-audit example.  Each
+# This example shows a context-schema audit in ordinary RDF/N3. Each
 # message carries a quoted context graph whose members encode an event name as
 # the predicate and its arguments as an RDF list.  A generic rule uses
 # log:includes to inspect those quoted contexts, list:length to compute arity,

package/eyeling.js

@@ -6483,7 +6483,6 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/index.d.ts

@@ -80,33 +80,7 @@ export interface N3SourceListInput {
   scopeBlankNodes?: boolean;
 }
 
-export type EngineName = 'n3' | 'eyeling' | 'eyelang' | 'prolog' | 'horn';
-
-export type EyelangSource = string | { eyelang?: string; prolog?: string; text?: string; label?: string };
-
-export interface EyelangSourceListInput {
-  sources: EyelangSource[];
-}
-
-export interface EyelangStats {
-  [key: string]: number;
-}
-
-export interface EyelangRunOptions {
-  engine?: EngineName;
-  proof?: boolean;
-  why?: boolean;
-  explain?: boolean;
-  stats?: boolean;
-  args?: string[];
-  maxBuffer?: number;
-  [key: string]: unknown;
-}
-
-export interface EyelangRunResult {
-  stdout: string;
-  stats: EyelangStats;
-}
+export type EngineName = 'n3' | 'eyeling';
 
 export interface RdfJsReasonInput {
   n3?: string;
@@ -150,7 +124,7 @@ export interface ReasonOptions {
   rdf?: boolean;
   rdf12?: boolean;
   n3?: boolean;
-  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  inputFormat?: 'auto' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
   args?: string[];
   maxBuffer?: number;
   builtinModules?: string | string[];
@@ -235,18 +209,12 @@ export class PersistentFactStore implements FactStore {
 
 export function reason(
   opts: ReasonOptions,
-  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput | EyelangSourceListInput,
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
 ): string;
-export function runAsync(
-  input: string,
-  opts: ReasonStreamOptions & { engine: 'eyelang' | 'prolog' | 'horn' },
-): Promise<EyelangRunResult>;
 export function runAsync(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
   opts?: ReasonStreamOptions & { engine?: 'n3' | 'eyeling' },
 ): Promise<ReasonStreamResult & { store?: FactStore }>;
-export function runEyelang(input: string, opts?: EyelangRunOptions): Promise<EyelangRunResult>;
-export function reasonEyelang(input: string, opts?: EyelangRunOptions): Promise<string>;
 export function reasonStream(
   input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
   opts?: ReasonStreamOptions,
@@ -269,8 +237,6 @@ export interface EyelingModule {
   readonly version: string;
   reason: typeof reason;
   runAsync: typeof runAsync;
-  runEyelang: typeof runEyelang;
-  reasonEyelang: typeof reasonEyelang;
   reasonStream: typeof reasonStream;
   reasonRdfJs: typeof reasonRdfJs;
   readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;

package/index.js

@@ -4,7 +4,6 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const cp = require('node:child_process');
-const { pathToFileURL } = require('node:url');
 
 const bundleApi = require('./eyeling.js');
 const { dataFactory, normalizeReasonerInputSync } = require('./lib/rdfjs');
@@ -12,88 +11,6 @@ const { isN3SourceListInput } = require('./lib/multisource');
 const engine = require('./lib/engine');
 
 
-function normalizeEngineName(value) {
-  if (value == null || value === '') return 'n3';
-  const name = String(value).toLowerCase();
-  if (name === 'n3' || name === 'eyeling') return 'n3';
-  if (name === 'eyelang' || name === 'prolog' || name === 'horn') return 'eyelang';
-  throw new TypeError(`unknown Eyeling engine: ${value}`);
-}
-
-function normalizeEyelangSourceForTempFile(source) {
-  if (typeof source === 'string') return source;
-  if (source && typeof source === 'object' && !Array.isArray(source)) {
-    const text =
-      typeof source.eyelang === 'string' ? source.eyelang
-        : typeof source.prolog === 'string' ? source.prolog
-          : typeof source.text === 'string' ? source.text
-            : null;
-    if (text !== null) return text;
-  }
-  throw new TypeError('reason({ engine: "eyelang" }, input): each source must be a string or an object with an eyelang/prolog/text field');
-}
-
-function normalizeEyelangInput(input) {
-  if (typeof input === 'string') return [input];
-  if (input == null) return [''];
-  if (input && typeof input === 'object' && !Array.isArray(input)) {
-    if (Array.isArray(input.sources)) return input.sources.map(normalizeEyelangSourceForTempFile);
-    return [normalizeEyelangSourceForTempFile(input)];
-  }
-  throw new TypeError('reason({ engine: "eyelang" }, input): input must be a string, source object, or { sources } list');
-}
-
-function reasonEyelangSync(opt = {}, input = '') {
-  const args = [];
-
-  if (opt.proof || opt.why || opt.explain) args.push('--proof');
-  if (opt.stats) args.push('--stats');
-  if (Array.isArray(opt.args)) args.push(...opt.args);
-
-  const maxBuffer = Number.isFinite(opt.maxBuffer) ? opt.maxBuffer : 50 * 1024 * 1024;
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-eyelang-'));
-
-  try {
-    const inputFiles = normalizeEyelangInput(input).map((text, index) => {
-      const inputFile = path.join(dir, `input-${index + 1}.pl`);
-      fs.writeFileSync(inputFile, text, 'utf8');
-      return inputFile;
-    });
-
-    const eyelangCliPath = path.join(__dirname, 'lib', 'eyelang', 'bin.js');
-    const res = cp.spawnSync(process.execPath, [eyelangCliPath, ...args, ...inputFiles], { encoding: 'utf8', maxBuffer });
-
-    if (res.error) throw res.error;
-    if (res.stderr) process.stderr.write(res.stderr);
-
-    if (res.status !== 0) {
-      const err = new Error(res.stderr || `eyelang exited with code ${res.status}`);
-      err.code = res.status;
-      err.stdout = res.stdout;
-      err.stderr = res.stderr;
-      throw err;
-    }
-
-    return res.stdout;
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-async function loadEyelangModule() {
-  return import(pathToFileURL(path.join(__dirname, 'lib', 'eyelang', 'index.js')).href);
-}
-
-async function runEyelang(input = '', opt = {}) {
-  const eyelang = await loadEyelangModule();
-  return eyelang.run(input, opt || {});
-}
-
-async function reasonEyelang(input = '', opt = {}) {
-  const result = await runEyelang(input, opt || {});
-  return result.stdout;
-}
-
 function reason(opt = {}, input = '') {
   if (input == null) input = '';
 
@@ -101,8 +18,6 @@ function reason(opt = {}, input = '') {
   if (Array.isArray(opt)) opt = { args: opt };
   if (opt == null || typeof opt !== 'object') opt = {};
 
-  if (normalizeEngineName(opt.engine) === 'eyelang') return reasonEyelangSync(opt, input);
-
   const args = [];
 
   // default: proof output OFF for API output (machine-friendly)
@@ -202,16 +117,12 @@ function reason(opt = {}, input = '') {
 }
 
 async function runAsync(input = '', opt = {}) {
-  const options = opt || {};
-  if (normalizeEngineName(options.engine) === 'eyelang') return runEyelang(input, options);
-  return engine.runAsync(input, options);
+  return engine.runAsync(input, opt || {});
 }
 
 module.exports = {
   reason,
   runAsync,
-  runEyelang,
-  reasonEyelang,
   reasonStream: bundleApi.reasonStream,
   reasonRdfJs: bundleApi.reasonRdfJs,
   rdfjs: dataFactory,

package/lib/cli.js

@@ -805,7 +805,6 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.34.4",
+  "version": "1.34.6",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -26,7 +26,6 @@
     "index.js",
     "index.d.ts",
     "browser.d.ts",
-    "eyelang.d.ts",
     "bin",
     "dist",
     "docs",
@@ -61,10 +60,7 @@
     "test:package": "node test/package.test.js",
     "test": "node test/run.js",
     "preversion": "npm test",
-    "postversion": "git push origin HEAD --follow-tags",
-    "test:eyelang": "node test/eyelang.test.js && node test/eyelang/run-all.mjs",
-    "test:eyelang:integration": "node test/eyelang.test.js",
-    "test:eyelang:corpus": "node test/eyelang/run-all.mjs"
+    "postversion": "git push origin HEAD --follow-tags"
   },
   "dependencies": {
     "@rdfjs/types": "^2.0.1"
@@ -85,12 +81,7 @@
       "default": "./dist/browser/index.mjs"
     },
     "./eyeling.js": "./eyeling.js",
-    "./package.json": "./package.json",
-    "./eyelang": {
-      "types": "./eyelang.d.ts",
-      "import": "./lib/eyelang/index.js",
-      "default": "./lib/eyelang/index.js"
-    }
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {

package/test/eyelang/conformance/README.md

@@ -4,8 +4,8 @@ This directory contains the executable conformance cases for the eyelang languag
 
 The suite is intentionally file-based so another implementation can run the same programs and compare exact standard output. A case consists of:
 
-- `conformance/cases/<profile>/<name>.pl` — input program;
-- `conformance/expected/<profile>/<name>.out` — exact expected standard output.
+- `conformance/cases/<name>.pl` — input program;
+- `conformance/expected/<name>.pl` — exact expected standard output, stored as eyelang-readable facts.
 
 The current runner compares standard output from normal execution. Proof explanations are opt-in in the CLI and are not part of these conformance goldens. Standard error, performance, and resource limits are outside this suite.
 
@@ -23,23 +23,21 @@ Run only the conformance suite:
 node test/eyelang/run-conformance.mjs
 ```
 
-Run a single conformance profile directly:
+Run matching conformance cases by passing a filename fragment:
 
 ```sh
-node test/eyelang/run-conformance.mjs core
-node test/eyelang/run-conformance.mjs extension
+node test/eyelang/run-conformance.mjs reusable
+node test/eyelang/run-conformance.mjs 092_scalar_string_conversions
 ```
 
 The runner executes materialized programs in-process through the public JavaScript API so small conformance cases avoid measuring Node startup overhead.
 
-## Profiles
+## Scope
 
-`core` covers the portable core language profile from the [eyelang language reference](../../../docs/eyelang-language-reference.md): lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification through user predicates, left-to-right goal-directed proof search, materialized output, and read-back printing.
+The conformance corpus is a single eyelang suite. It covers the standard language described by the language reference: lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification, left-to-right goal-directed proof search, materialized output, read-back printing, standard built-ins, declarations, and standard host behavior.
 
-`extension` covers the standard built-in and host behavior exercised by the current reference implementation: arithmetic, comparison, strings, list relations, aggregation, context-term helpers, term-inspection helpers, search-control helpers, `memoize/2`, `materialize/2`, and default derived output.
-
-The profile name `extension` is a test-suite grouping name. It does not mean that these cases are outside the eyelang language reference; most of them correspond to the standard built-in profile and standard host profile in the [eyelang language reference](../../../docs/eyelang-language-reference.md).
+The suite deliberately does not separate `core` and `extension` profiles. Reusable built-ins such as arithmetic, strings, lists, aggregation, context terms, term inspection, and search control are part of the standard eyelang conformance surface. Implementation-specific built-ins may still exist in downstream hosts, but they should have their own tests outside this corpus unless they are standardized.
 
 ## Updating expected output
 
-There is no committed auto-accept mode. To update an expected file, run the matching case with the conformance runner, inspect the result, and replace the corresponding file under `conformance/expected/<profile>/` deliberately.
+There is no committed auto-accept mode. To update an expected file, run the matching case with the conformance runner, inspect the result, and replace the corresponding file under `conformance/expected/` deliberately.

package/test/eyelang/conformance/cases/001_fact_output.pl

@@ -0,0 +1,4 @@
+% Reference 6, 7, 11: facts can be exposed through a materialized derived predicate.
+materialize(parent, 2).
+base_parent(pat, jan).
+parent(X, Y) :- base_parent(X, Y).

package/test/eyelang/conformance/cases/002_rule_recursion.pl

@@ -0,0 +1,7 @@
+% Reference 6, 7: definite clauses, conjunction, and recursive proof search.
+materialize(ancestor, 2).
+parent(pat, jan).
+parent(jan, emma).
+ancestor_any(X, Y) :- parent(X, Y).
+ancestor_any(X, Z) :- parent(X, Y), ancestor_any(Y, Z).
+ancestor(pat, Y) :- ancestor_any(pat, Y).

package/test/eyelang/conformance/cases/002_rule_recursion.query

@@ -0,0 +1 @@
+ancestor(pat, X)

package/test/eyelang/conformance/cases/003_terms_and_readback.pl

@@ -0,0 +1,16 @@
+% Reference 3, 5, 11: scalars, compounds, lists, and read-back printing.
+materialize(value, 2).
+raw_value(atom, pat).
+raw_value(quoted_atom, 'atom with spaces').
+raw_value(quoted_quote, 'needs''quote').
+raw_value(empty_atom, '').
+raw_value(string, "line\nquote: \"ok\"").
+raw_value(integer, -42).
+raw_value(decimal, 0.25).
+raw_value(scientific, 1.25e-3).
+raw_value(compound, pair(3, nested(atom, [x, y]))).
+raw_value(zero_arity, nil()).
+raw_value(empty_list, []).
+raw_value(proper_list, [a, b, c]).
+raw_value(improper_list, [a, b | tail]).
+value(K, V) :- raw_value(K, V).

package/test/eyelang/conformance/cases/003_terms_and_readback.query

@@ -0,0 +1 @@
+value(K, V)

package/test/eyelang/conformance/cases/004_conjunction_and_parentheses.pl

@@ -0,0 +1,5 @@
+% Reference 5.5, 7: parenthesized comma terms are conjunctions in goal position.
+p(a).
+q(a).
+ok(X, yes) :- (p(X), q(X)).
+materialize(ok, 2).

package/test/eyelang/conformance/cases/004_conjunction_and_parentheses.query

@@ -0,0 +1 @@
+ok(X, Y)

package/test/eyelang/conformance/cases/005_list_deconstruction.pl

@@ -0,0 +1,6 @@
+% Reference 5.4, 12.1: list syntax and unification in rule heads.
+first([X | _Rest], X).
+tail([_Head | Tail], Tail).
+answer(first, X) :- first([a, b, c], X).
+answer(tail, Tail) :- tail([a, b, c], Tail).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/005_list_deconstruction.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/006_comma_formula_data.pl

@@ -0,0 +1,4 @@
+% Reference 5.5: comma terms remain data outside goal position.
+record((name(alice, "Alice"), knows(alice, bob))).
+answer(formula, F) :- record(F).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/006_comma_formula_data.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/007_anonymous_variables.pl

@@ -0,0 +1,5 @@
+% Reference 3.4, 5.1, 7.1: each anonymous variable occurrence is fresh.
+pair(a, one).
+pair(b, two).
+answer(fresh, yes) :- pair(a, _), pair(b, _).
+materialize(answer, 2).

package/test/eyelang/conformance/cases/007_anonymous_variables.query

@@ -0,0 +1 @@
+answer(K, V)

package/test/eyelang/conformance/cases/008_graphic_atoms.pl

@@ -0,0 +1,6 @@
+% Reference 3.5, 5.2, 11: graphic atom constants are scalar terms.
+materialize(value, 2).
+raw_value(hash, #).
+raw_value(arrow, =>).
+raw_value(comparison, =<).
+value(K, V) :- raw_value(K, V).