eyeling 1.5.15 → 1.5.17

package/README.md

@@ -4,12 +4,13 @@ A minimal [Notation3 (N3)](https://notation3.org/) reasoner in **JavaScript**.
 
 `eyeling` is:
 
-- a single self-contained file (`eyeling.js`, no external deps),
-- intentionally tiny and close in spirit to EYE,
-- a practical N3/Turtle superset (enough for lots of real rulesets),
-- supports forward (`=>`) + backward (`<=`) chaining over Horn-style rules,
-- prints only newly derived forward facts, optionally preceded by compact proof comments,
-- we never want to leak raw data, hence pass-only-new and backward rules for functions that work with raw data, and of course we also keep all reasoning in the browser.
+- a single self-contained file (`eyeling.js`, no external deps)
+- intentionally tiny and close in spirit to EYE
+- a practical N3/Turtle superset (enough for lots of real rulesets)
+- supports forward (`=>`) + backward (`<=`) chaining over Horn-style rules
+- prints only newly derived forward facts, optionally preceded by compact proof comments
+- we never want to leak raw data, hence pass-only-new and backward rules for functions that work with raw data
+- and of course we also keep all reasoning in the browser
 
 ## Playground (in your browser)
 
@@ -18,21 +19,22 @@ Try it here:
 - [Eyeling playground](https://eyereasoner.github.io/eyeling/demo)
 
 The playground runs `eyeling` client-side. You can:
-- edit an N3 program directly,
-- load an N3 program from a URL,
-- share a link with the program encoded in the URL fragment (`#...`).  
+
+- edit an N3 program directly
+- load an N3 program from a URL
+- share a link with the program encoded in the URL fragment (`#...`)
 
 ### Example (Socrates)
 
 This link preloads a small “Socrates is Mortal” ruleset:
 
-[Socrates example](https://eyereasoner.github.io/eyeling/demo#%23%20------------------%0A%23%20Socrates%20inference%0A%23%20------------------%0A%0A%40prefix%20rdfs%3A%20%3Chttp%3A%2F%2Fwww.w3.org%2F2000%2F01%2Frdf-schema%23%3E.%0A%40prefix%20%3A%20%3Chttp%3A%2F%2Fexample.org%2Fsocrates%23%3E.%0A%0A%23%20facts%0A%3ASocrates%20a%20%3AHuman.%0A%3AHuman%20rdfs%3AsubClassOf%20%3AMortal.%0A%0A%23%20subclass%20rule%0A%7B%0A%20%20%20%20%3FS%20a%20%3FA.%0A%20%20%20%20%3FA%20rdfs%3AsubClassOf%20%3FB.%0A%7D%20%3D%3E%20%7B%0A%20%20%20%20%3FS%20a%20%3FB.%0A%7D%2E%0A)
+- [Socrates example](https://eyereasoner.github.io/eyeling/demo#%23%20------------------%0A%23%20Socrates%20inference%0A%23%20------------------%0A%0A%40prefix%20rdfs%3A%20%3Chttp%3A%2F%2Fwww.w3.org%2F2000%2F01%2Frdf-schema%23%3E.%0A%40prefix%20%3A%20%3Chttp%3A%2F%2Fexample.org%2Fsocrates%23%3E.%0A%0A%23%20facts%0A%3ASocrates%20a%20%3AHuman.%0A%3AHuman%20rdfs%3AsubClassOf%20%3AMortal.%0A%0A%23%20subclass%20rule%0A%7B%0A%20%20%20%20%3FS%20a%20%3FA.%0A%20%20%20%20%3FA%20rdfs%3AsubClassOf%20%3FB.%0A%7D%20%3D%3E%20%7B%0A%20%20%20%20%3FS%20a%20%3FB.%0A%7D%2E%0A)
 
 ## Quick start (Node.js)
 
 ### Requirements
 
-- A reasonably recent Node.js (anything modern with `BigInt` support is fine).
+- Node.js >= 18 (anything modern with `BigInt` support is fine)
 
 ### Install (npm)
 
@@ -53,7 +55,7 @@ npx eyeling examples/socrates.n3
 ### JavaScript API (Node)
 
 ```js
-const { reason } = require('eyeling');
+const { reason } = require("eyeling");
 
 const input = `
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
@@ -72,7 +74,7 @@ console.log(output);
 ESM:
 
 ```js
-import eyeling from 'eyeling';
+import eyeling from "eyeling";
 
 const output = eyeling.reason({ proofComments: false }, input);
 console.log(output);
@@ -80,6 +82,28 @@ console.log(output);
 
 Note: the API currently shells out to the bundled `eyeling.js` CLI under the hood (simple + robust).
 
+### Testing
+
+From a repo checkout:
+
+```bash
+npm test
+```
+
+Or run individual suites:
+
+```bash
+npm run test:api
+npm run test:examples
+npm run test:package
+npm run test:packlist
+```
+
+- `test:api` runs an independent JS API test suite (does not rely on `examples/`).
+- `test:examples` runs the examples in `examples` directory and compares against the golden outputs in `examples/output`.
+- `test:package` does a “real consumer” smoke test: `npm pack` → install tarball into a temp project → run API + CLI + examples.
+- `test:packlist` sanity-checks what will be published in the npm tarball (and the CLI shebang/bin wiring).
+
 ### Run a single file
 
 From the repo root:
@@ -94,10 +118,10 @@ node eyeling.js examples/socrates.n3
 
 By default, `eyeling`:
 
-1. parses the input (facts + rules),
-2. runs **forward chaining to a fixpoint**,
-3. prints only **newly derived forward facts** (not the original input facts),
-4. prints a compact per-triple explanation as `#` comments (can be disabled).
+1. parses the input (facts + rules)
+2. runs **forward chaining to a fixpoint**
+3. prints only **newly derived forward facts** (not the original input facts)
+4. prints a compact per-triple explanation as `#` comments (can be disabled)
 
 ### Options
 
@@ -116,7 +140,8 @@ node eyeling.js -n examples/socrates.n3
 npm run test:examples
 ```
 
-This runs `eyeling.js` over each example and compares against the golden outputs in `examples/output`.
+This runs `eyeling.js` over each example and compares against the golden outputs in `examples/output`
+(works both in a git checkout and in an npm-installed package).
 
 ## What output do I get?
 
@@ -131,14 +156,14 @@ The proof comments are compact “local justifications” per derived triple (no
 
 ### Forward + backward chaining
 
-* **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
-* **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
+- **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
+- **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
 
 Forward rule premises are proved using:
 
-* ground facts (input + derived),
-* backward rules,
-* built-ins.
+- ground facts (input + derived)
+- backward rules
+- built-ins
 
 The CLI prints only newly derived forward facts.
 
@@ -146,63 +171,59 @@ The CLI prints only newly derived forward facts.
 
 `eyeling` stays tiny, but includes a few key performance mechanisms:
 
-* facts are indexed for matching:
-
-  * by predicate, and (when possible) by **(predicate, object)** (important for type-heavy workloads),
-* duplicate detection uses a fast key path when a triple is fully IRI/Literal-shaped,
-* backward rules are indexed by head predicate,
-* the backward prover is **iterative** (explicit stack), so deep chains won’t blow the JS call stack,
-* for very deep backward chains, substitutions may be compactified (semantics-preserving) to avoid quadratic “copy a growing substitution object” behavior.
+- facts are indexed for matching:
+  - by predicate, and (when possible) by **(predicate, object)** (important for type-heavy workloads)
+- duplicate detection uses a fast key path when a triple is fully IRI/Literal-shaped
+- backward rules are indexed by head predicate
+- the backward prover is **iterative** (explicit stack), so deep chains won’t blow the JS call stack
+- for very deep backward chains, substitutions may be compactified (semantics-preserving) to avoid quadratic “copy a growing substitution object” behavior
 
 ## Parsing: practical N3 subset
 
 Supported:
 
-* `@prefix` / `@base`
-* triples with `;` and `,`
-* variables `?x`
-* blank nodes:
-
-  * anonymous `[]`
-  * property lists `[ :p :o; :q :r ]`
-  * collections `( ... )`
-* quoted formulas `{ ... }`
-* implications:
-
-  * forward rules `{ P } => { C } .`
-  * backward rules `{ H } <= { B } .`
-* datatyped literals with `^^`
-* `#` line comments
+- `@prefix` / `@base`
+- triples with `;` and `,`
+- variables `?x`
+- blank nodes:
+  - anonymous `[]`
+  - property lists `[ :p :o; :q :r ]`
+- collections `( ... )`
+- quoted formulas `{ ... }`
+- implications:
+  - forward rules `{ P } => { C } .`
+  - backward rules `{ H } <= { B } .`
+- datatyped literals with `^^`
+- `#` line comments
 
 Non-goals / current limits:
 
-* not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax),
-* quoted formulas are matched as whole formulas (no pattern matching inside formulas yet),
-* proof output is local per derived triple (not a global exported proof tree).
+- not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
+- quoted formulas are matched as whole formulas (no pattern matching inside formulas yet)
+- proof output is local per derived triple (not a global exported proof tree)
 
 ## Blank nodes and quantification (pragmatic N3/EYE-style)
 
 `eyeling` follows the usual N3 intuition:
 
-1. blank nodes in facts are normal RDF blanks (`_:b1`, `_:b2`, … within a run),
-2. blank nodes in rule premises behave like rule-scoped universals (similar to variables),
-3. blank nodes only in rule conclusions behave like existentials:
-   each rule firing generates fresh Skolem blanks (`_:sk_0`, `_:sk_1`, …).
+1. blank nodes in facts are normal RDF blanks (`_:b1`, `_:b2`, … within a run)
+2. blank nodes in rule premises behave like rule-scoped universals (similar to variables)
+3. blank nodes only in rule conclusions behave like existentials: each rule firing generates fresh Skolem blanks (`_:sk_0`, `_:sk_1`, …)
 
 Equal facts up to renaming of Skolem IDs are treated as duplicates and are not re-added.
 
 ## Rule-producing rules (meta-rules)
 
-`eyeling` understands the `log:implies` / `log:impliedBy` idiom:
+`eyeling` understands the `log:implies` / `log:impliedBy` idiom.
 
 Top level:
 
-* `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
-* `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
+- `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
+- `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
 
 During reasoning:
 
-* any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
+- any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
 
 ## Inference fuse — `{ ... } => false.`
 
@@ -211,6 +232,7 @@ Rules whose conclusion is `false` are treated as hard failures:
 ```n3
 :stone :color :black .
 :stone :color :white .
+
 { ?X :color :black . ?X :color :white . } => false.
 ```
 
@@ -220,13 +242,12 @@ As soon as the premise is provable, `eyeling` exits with status code `2`.
 
 `eyeling` implements a pragmatic subset of common N3 builtin families and evaluates them during backward goal proving:
 
-* **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
-* **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:reverse` `list:sort`
-* **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
-* **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
-* **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
-* **time**: `time:localTime`
-
+- **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
+- **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:reverse` `list:sort`
+- **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
+- **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
+- **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
+- **time**: `time:localTime`
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.5.15",
+  "version": "1.5.17",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -31,8 +31,10 @@
   "scripts": {
     "test:packlist": "node test/packlist.test.js",
     "test:api": "node test/api.test.js",
-    "test:examples": "bash -lc 'cd examples && ./test'",
-    "test:package": "bash test/package-smoke.sh",
-    "test": "npm run test:packlist && npm run test:api && npm run test:examples"
+    "test:examples": "node test/examples.test.js",
+    "test:package": "node test/package.test.js",
+    "test": "npm run test:packlist && npm run test:api && npm run test:examples",
+    "preversion": "npm test",
+    "postversion": "git push origin HEAD --follow-tags"
   }
 }

package/test/api.test.js

@@ -556,6 +556,7 @@ let passed = 0;
 let failed = 0;
 
 (async function main() {
+  const suiteStart = Date.now();
   info(`Running ${cases.length} API tests (independent of examples/)`);
 
   for (const tc of cases) {
@@ -602,6 +603,8 @@ let failed = 0;
   }
 
   console.log('');
+  const suiteMs = Date.now() - suiteStart;
+  console.log(`${C.y}==${C.n} Total elapsed: ${suiteMs} ms`);
   if (failed === 0) {
     ok(`All API tests passed (${passed}/${cases.length})`);
     process.exit(0);

package/test/examples.test.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const TTY = process.stdout.isTTY;
+const C = TTY
+  ? { g: '\x1b[32m', r: '\x1b[31m', y: '\x1b[33m', dim: '\x1b[2m', n: '\x1b[0m' }
+  : { g: '', r: '', y: '', dim: '', n: '' };
+
+function ok(msg)   { console.log(`${C.g}OK${C.n}  ${msg}`); }
+function fail(msg) { console.error(`${C.r}FAIL${C.n} ${msg}`); }
+function info(msg) { console.log(`${C.y}==${C.n} ${msg}`); }
+
+function padRight(s, n) {
+  s = String(s);
+  return s.length >= n ? s : (s + ' '.repeat(n - s.length));
+}
+
+function padLeft(s, n) {
+  s = String(s);
+  return s.length >= n ? s : (' '.repeat(n - s.length) + s);
+}
+
+function run(cmd, args, opts = {}) {
+  return cp.spawnSync(cmd, args, {
+    encoding: 'utf8',
+    maxBuffer: 200 * 1024 * 1024,
+    ...opts,
+  });
+}
+
+function hasGit() {
+  const r = run('git', ['--version']);
+  return r.status === 0;
+}
+
+function inGitWorktree(cwd) {
+  if (!hasGit()) return false;
+  const r = run('git', ['rev-parse', '--is-inside-work-tree'], { cwd });
+  return r.status === 0 && String(r.stdout).trim() === 'true';
+}
+
+// Expectation logic (same as bash version):
+// 1) If file contains a comment like: # expect-exit: 2  -> use that
+// 2) Else, if it contains "=> false" -> expect exit 2
+// 3) Else -> expect exit 0
+function expectedExitCode(n3Text) {
+  const m = n3Text.match(/^[ \t]*#[: ]*expect-exit:[ \t]*([0-9]+)\b/m);
+  if (m) return parseInt(m[1], 10);
+  if (/=>\s*false\b/.test(n3Text)) return 2;
+  return 0;
+}
+
+function getEyelingVersion(nodePath, eyelingJsPath, cwd) {
+  const r = run(nodePath, [eyelingJsPath, '-v'], { cwd });
+  // eyeling prints version to stdout in your CLI
+  const s = (r.stdout || r.stderr || '').trim();
+  return s || 'eyeling (unknown version)';
+}
+
+function mkTmpFile() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-examples-'));
+  const file = path.join(dir, 'generated.n3');
+  return { dir, file };
+}
+
+function rmrf(p) {
+  try { fs.rmSync(p, { recursive: true, force: true }); } catch {}
+}
+
+function main() {
+  const suiteStart = Date.now();
+
+  // package root: .../test/examples.test.js -> root is one level up
+  const root = path.resolve(__dirname, '..');
+  const examplesDir = path.join(root, 'examples');
+  const outputDir = path.join(examplesDir, 'output');
+  const eyelingJsPath = path.join(root, 'eyeling.js');
+  const nodePath = process.execPath;
+
+  if (!fs.existsSync(examplesDir)) {
+    fail(`Missing examples directory: ${examplesDir}`);
+    process.exit(1);
+  }
+  if (!fs.existsSync(eyelingJsPath)) {
+    fail(`Missing eyeling.js: ${eyelingJsPath}`);
+    process.exit(1);
+  }
+
+  const IN_GIT = inGitWorktree(root);
+
+  // Header
+  console.log(`${C.y}-------------------------------------------------${C.n}`);
+  console.log(`${C.y}running eyeling examples${C.n}`);
+  console.log(
+    `${C.y}using ${getEyelingVersion(nodePath, eyelingJsPath, root)} and node ${process.version}${C.n}`
+  );
+  console.log(`${C.y}-------------------------------------------------${C.n}`);
+  console.log('');
+
+  // In maintainer mode we write expected outputs (tracked) to examples/output/
+  if (IN_GIT) fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs.readdirSync(examplesDir)
+    .filter(f => f.endsWith('.n3'))
+    .sort((a, b) => a.localeCompare(b));
+
+  if (files.length === 0) {
+    info('No .n3 files found in examples/');
+    process.exit(0);
+  }
+
+  let OK = 0;
+  let DIFF = 0;
+
+  for (const file of files) {
+    const filePath = path.join(examplesDir, file);
+    const expectedPath = path.join(outputDir, file); // examples/output/<file>
+
+    const start = Date.now();
+
+    let n3Text = '';
+    try {
+      n3Text = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      const ms = Date.now() - start;
+      process.stdout.write(padRight(file, 36));
+      process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
+      console.log(`${C.r}DIFF${C.n} (cannot read input: ${e.message})`);
+      DIFF++;
+      continue;
+    }
+
+    const expectedRc = expectedExitCode(n3Text);
+
+    // Decide where to write generated output
+    let tmp = null;
+    let generatedPath = expectedPath;
+
+    if (!IN_GIT) {
+      // npm-installed / no .git: never modify output/ in node_modules
+      if (!fs.existsSync(expectedPath)) {
+        const ms = Date.now() - start;
+        process.stdout.write(padRight(file, 36));
+        process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
+        console.log(`${C.r}MISSING expected output/${file}${C.n}`);
+        DIFF++;
+        continue;
+      }
+      tmp = mkTmpFile();
+      generatedPath = tmp.file;
+    }
+
+    // Run eyeling, capture exit code without aborting the suite
+    // We run `node eyeling.js <file>` from examplesDir so relative paths match old behavior.
+    const r = run(nodePath, [eyelingJsPath, file], { cwd: examplesDir });
+    const rc = (r.status == null) ? 1 : r.status;
+
+    // Write stdout to the chosen output file (expected in git mode, tmp in npm mode)
+    try {
+      fs.writeFileSync(generatedPath, r.stdout || '', 'utf8');
+    } catch (e) {
+      const ms = Date.now() - start;
+      process.stdout.write(padRight(file, 36));
+      process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
+      console.log(`${C.r}DIFF${C.n} (cannot write output: ${e.message})`);
+      DIFF++;
+      if (tmp) rmrf(tmp.dir);
+      continue;
+    }
+
+    const ms = Date.now() - start;
+
+    // Compare outputs
+    let diffOk = false;
+
+    if (IN_GIT) {
+      // Compare expectedPath against HEAD using git diff
+      const d = run('git', ['diff', '--quiet', '--', path.posix.join('output', file)], { cwd: examplesDir });
+      diffOk = (d.status === 0);
+    } else {
+      // Compare expectedPath vs generatedPath without needing a repo
+      if (hasGit()) {
+        const d = run('git', ['diff', '--no-index', '--quiet', expectedPath, generatedPath], { cwd: examplesDir });
+        diffOk = (d.status === 0);
+      } else {
+        const d = run('diff', ['-u', expectedPath, generatedPath], { cwd: examplesDir });
+        diffOk = (d.status === 0);
+      }
+    }
+
+    // Decide pass/fail
+    process.stdout.write(padRight(file, 36));
+    process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
+
+    if (diffOk && rc === expectedRc) {
+      if (rc === 0) {
+        console.log(`${C.g}OK${C.n}`);
+      } else {
+        console.log(`${C.g}OK${C.n} (exit ${rc})`);
+      }
+      OK++;
+    } else {
+      if (rc !== expectedRc) {
+        console.log(`${C.r}DIFF${C.n} (exit ${rc}, expected ${expectedRc})`);
+      } else {
+        console.log(`${C.r}DIFF${C.n}`);
+      }
+      DIFF++;
+
+      // In npm mode, show a diff (nice UX) without modifying node_modules
+      if (!IN_GIT) {
+        if (hasGit()) {
+          const d = run('git', ['diff', '--no-index', expectedPath, generatedPath], { cwd: examplesDir });
+          if (d.stdout) process.stdout.write(d.stdout);
+          if (d.stderr) process.stderr.write(d.stderr);
+        } else {
+          const d = run('diff', ['-u', expectedPath, generatedPath], { cwd: examplesDir });
+          if (d.stdout) process.stdout.write(d.stdout);
+          if (d.stderr) process.stderr.write(d.stderr);
+        }
+      }
+    }
+
+    // cleanup tmp file
+    if (tmp) rmrf(tmp.dir);
+  }
+
+  console.log('');
+  const suiteMs = Date.now() - suiteStart;
+  console.log(`${C.y}==${C.n} Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
+  console.log(`${C.y}==${C.n} ${C.g}${OK} OK${C.n}  ${C.r}${DIFF} DIFF${C.n}`);
+
+  process.exit(DIFF === 0 ? 0 : 2);
+}
+
+main();
+

package/test/package.test.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const TTY = process.stdout.isTTY;
+const C = TTY
+  ? { g: '\x1b[32m', r: '\x1b[31m', y: '\x1b[33m', dim: '\x1b[2m', n: '\x1b[0m' }
+  : { g: '', r: '', y: '', dim: '', n: '' };
+
+function info(msg) { console.log(`${C.y}==${C.n} ${msg}`); }
+function ok(msg)   { console.log(`${C.g}OK${C.n}  ${msg}`); }
+function fail(msg) { console.error(`${C.r}FAIL${C.n} ${msg}`); }
+
+function isWin() { return process.platform === 'win32'; }
+function npmCmd() { return isWin() ? 'npm.cmd' : 'npm'; }
+
+function rmrf(p) {
+  try { fs.rmSync(p, { recursive: true, force: true }); } catch {}
+}
+
+function run(cmd, args, opts = {}) {
+  const res = cp.spawnSync(cmd, args, {
+    encoding: 'utf8',
+    maxBuffer: 200 * 1024 * 1024,
+    ...opts,
+  });
+  return res;
+}
+
+function runChecked(cmd, args, opts = {}) {
+  // Print the command in a dim style
+  console.log(`${C.dim}$ ${cmd} ${args.join(' ')}${C.n}`);
+  const res = run(cmd, args, opts);
+  if (res.error) throw res.error;
+  if (res.status !== 0) {
+    const err = new Error(`Command failed (${cmd} ${args.join(' ')}), exit ${res.status}`);
+    err.code = res.status;
+    err.stdout = res.stdout;
+    err.stderr = res.stderr;
+    throw err;
+  }
+  return res;
+}
+
+function packTarball(root) {
+  // `npm pack --silent` prints the filename (usually one line)
+  const res = runChecked(npmCmd(), ['pack', '--silent'], { cwd: root });
+  const out = String(res.stdout || '').trim().split(/\r?\n/).filter(Boolean);
+  if (out.length === 0) throw new Error('npm pack produced no output');
+  return out[out.length - 1].trim(); // tarball filename in root
+}
+
+function main() {
+  const suiteStart = Date.now();
+  const root = path.resolve(__dirname, '..');
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-smoke-'));
+  const cleanup = () => rmrf(tmp);
+
+  let tgzInRoot = null;
+
+  try {
+    info('Building tarball (npm pack)');
+    tgzInRoot = packTarball(root);
+    const srcTgz = path.join(root, tgzInRoot);
+    const dstTgz = path.join(tmp, tgzInRoot);
+
+    fs.renameSync(srcTgz, dstTgz);
+
+    info('Creating temp project + installing tarball');
+    runChecked(npmCmd(), ['init', '-y'], { cwd: tmp, stdio: 'ignore' });
+    runChecked(npmCmd(), ['install', `./${tgzInRoot}`, '--no-audit', '--no-fund'], { cwd: tmp, stdio: 'inherit' });
+
+    info('API smoke test');
+    // Run a tiny API check via node -e
+    const apiCode = `
+      const { reason } = require('eyeling');
+      const input = \`
+{ <http://example.org/s> <http://example.org/p> <http://example.org/o>. }
+  => { <http://example.org/s> <http://example.org/q> <http://example.org/o>. }.
+
+<http://example.org/s> <http://example.org/p> <http://example.org/o>.
+\`;
+      const out = reason({ proofComments: false }, input);
+      const re = /<http:\\/\\/example\\.org\\/s>\\s+<http:\\/\\/example\\.org\\/q>\\s+<http:\\/\\/example\\.org\\/o>\\s*\\./;
+      if (!re.test(out)) {
+        console.error('Unexpected output:\\n' + out);
+        process.exit(1);
+      }
+      console.log('OK: API works');
+    `;
+    runChecked(process.execPath, ['-e', apiCode], { cwd: tmp, stdio: 'inherit' });
+    ok('API works');
+
+    info('CLI smoke test');
+    const bin = isWin()
+      ? path.join(tmp, 'node_modules', '.bin', 'eyeling.cmd')
+      : path.join(tmp, 'node_modules', '.bin', 'eyeling');
+    runChecked(bin, ['-v'], { cwd: tmp, stdio: 'inherit' });
+    ok('CLI works');
+
+    info('Examples test (installed package)');
+    const examplesRunner = path.join(tmp, 'node_modules', 'eyeling', 'test', 'examples.test.js');
+    runChecked(process.execPath, [examplesRunner], { cwd: tmp, stdio: 'inherit' });
+    ok('Installed examples test passed');
+
+    const suiteMs = Date.now() - suiteStart;
+    console.log('');
+    ok(`Packaged install smoke test passed ${C.dim}(${suiteMs} ms, ${(suiteMs / 1000).toFixed(2)} s)${C.n}`);
+    process.exit(0);
+  } catch (e) {
+    console.log('');
+    fail(e && e.stack ? e.stack : String(e));
+    process.exit(1);
+  } finally {
+    // If rename failed and the tarball still exists in root, try to delete it
+    if (tgzInRoot) {
+      const maybe = path.join(root, tgzInRoot);
+      if (fs.existsSync(maybe)) {
+        try { fs.unlinkSync(maybe); } catch {}
+      }
+    }
+    cleanup();
+  }
+}
+
+main();
+

package/test/packlist.test.js

@@ -45,7 +45,6 @@ try {
     'LICENSE.md',
     'eyeling.js',
     'index.js',
-    'examples/test',
   ];
 
   for (const p of mustHave) assert.ok(paths.has(p), `missing from npm pack: ${p}`);

package/examples/test

@@ -1,154 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-RED="\e[31m"
-GREEN="\e[32m"
-YELLOW="\e[33m"
-NORMAL="\e[0;39m"
-
-OK=0
-DIFF=0
-
-pad() {
-  # pad "text" width
-  local s="$1" w="$2"
-  printf "%-${w}s" "$s"
-}
-
-now_ms() {
-  echo $(( $(date +%s%N) / 1000000 ))
-}
-
-in_git_worktree() {
-  command -v git >/dev/null 2>&1 && git rev-parse --is-inside-work-tree >/dev/null 2>&1
-}
-
-# Expectation logic:
-# 1) If the .n3 contains a comment like:  # expect-exit: 2  -> use that
-# 2) Else, if it contains "=> false" -> expect exit 2
-# 3) Else -> expect exit 0
-expected_exit_code() {
-  local file="$1"
-  local line
-  if line=$(grep -Em1 '^[[:space:]]*#[: ]*expect-exit:[[:space:]]*[0-9]+' "$file" 2>/dev/null); then
-    if [[ "$line" =~ ([0-9]+) ]]; then
-      echo "${BASH_REMATCH[1]}"
-      return
-    fi
-  fi
-  if grep -Eq '=>[[:space:]]*false\b' "$file"; then
-    echo 2
-  else
-    echo 0
-  fi
-}
-
-echo -e "${YELLOW}-------------------------------------------------${NORMAL}"
-echo -e "${YELLOW}running eyeling examples${NORMAL}"
-echo -e "${YELLOW}using $(../eyeling.js -v) and node $(node --version)${NORMAL}"
-echo -e "${YELLOW}-------------------------------------------------${NORMAL}"
-echo ""
-
-IN_GIT=0
-if in_git_worktree; then IN_GIT=1; fi
-
-# In maintainer mode we write expected outputs (tracked) to output/
-if [[ $IN_GIT -eq 1 ]]; then
-  mkdir -p output
-fi
-
-begin="$(now_ms)"
-
-for file in *.n3; do
-  printf "%s" "$(pad "$file" 36)"
-  start="$(now_ms)"
-
-  expected_rc="$(expected_exit_code "$file")"
-
-  # Decide where we write generated output
-  tmp=""
-  generated=""
-  expected="output/${file}"
-
-  if [[ $IN_GIT -eq 1 ]]; then
-    generated="$expected"            # overwrite expected output in working tree
-  else
-    # npm-installed / no .git: never modify output/ in node_modules
-    if [[ ! -f "$expected" ]]; then
-      end="$(now_ms)"
-      ms=$((end-start))
-      echo -en "${YELLOW}$(pad "${ms} ms" 10)${NORMAL} "
-      echo -e "${RED}MISSING expected ${expected}${NORMAL}"
-      ((++DIFF))
-      continue
-    fi
-    tmp="$(mktemp)"
-    generated="$tmp"
-  fi
-
-  # Run eyeling, capture exit code without breaking the loop
-  rc=0
-  if ../eyeling.js "$file" > "$generated"; then
-    rc=0
-  else
-    rc=$?
-  fi
-
-  end="$(now_ms)"
-  ms=$((end-start))
-  echo -en "${YELLOW}$(pad "${ms} ms" 10)${NORMAL} "
-
-  # Compare output
-  diff_ok=0
-  if [[ $IN_GIT -eq 1 ]]; then
-    if git diff --quiet -- "$expected"; then diff_ok=1; fi
-  else
-    if command -v git >/dev/null 2>&1; then
-      if git diff --no-index --quiet -- "$expected" "$generated" >/dev/null 2>&1; then diff_ok=1; fi
-    else
-      if diff -u "$expected" "$generated" >/dev/null 2>&1; then diff_ok=1; fi
-    fi
-  fi
-
-  # Decide pass/fail
-  if [[ $diff_ok -eq 1 && $rc -eq $expected_rc ]]; then
-    if [[ $rc -eq 0 ]]; then
-      echo -e "${GREEN}OK${NORMAL}"
-    else
-      echo -e "${GREEN}OK${NORMAL} (exit ${rc})"
-    fi
-    ((++OK))
-  else
-    if [[ $rc -ne $expected_rc ]]; then
-      echo -e "${RED}DIFF${NORMAL} (exit ${rc}, expected ${expected_rc})"
-    else
-      echo -e "${RED}DIFF${NORMAL}"
-    fi
-    ((++DIFF))
-
-    # In npm mode, show a git-style diff when available (nice UX)
-    if [[ $IN_GIT -eq 0 ]]; then
-      if command -v git >/dev/null 2>&1; then
-        git diff --no-index -- "$expected" "$generated" || true
-      else
-        diff -u "$expected" "$generated" || true
-      fi
-    fi
-  fi
-
-  # cleanup tmp file
-  if [[ -n "$tmp" ]]; then rm -f "$tmp"; fi
-done
-
-end="$(now_ms)"
-total=$((end-begin))
-
-echo ""
-echo -e "${YELLOW}${total} ms${NORMAL} ${GREEN}${OK} OK${NORMAL} ${RED}${DIFF} DIFF${NORMAL}"
-
-if [[ ${DIFF} -eq 0 ]]; then
-  exit 0
-else
-  exit 2
-fi
-

package/test/package-smoke.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [ -t 1 ]; then
-  RED=$'\e[31m'; GREEN=$'\e[32m'; YELLOW=$'\e[33m'; NORMAL=$'\e[0m'
-else
-  RED=""; GREEN=""; YELLOW=""; NORMAL=""
-fi
-
-say() { echo -e "${YELLOW}== $* ==${NORMAL}"; }
-ok()  { echo -e "${GREEN}OK${NORMAL} $*"; }
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-TMP="$(mktemp -d)"
-cleanup() { rm -rf "$TMP"; }
-trap cleanup EXIT
-
-cd "$ROOT"
-
-say "Building tarball"
-TGZ="$(npm pack --silent)"
-mv "$TGZ" "$TMP/"
-cd "$TMP"
-
-say "Installing tarball into temp project"
-npm init -y >/dev/null 2>&1
-npm install "./$TGZ" >/dev/null 2>&1
-
-say "API smoke test"
-node - <<'NODE'
-const { reason } = require('eyeling');
-const input = `
-{ <http://example.org/s> <http://example.org/p> <http://example.org/o>. }
-  => { <http://example.org/s> <http://example.org/q> <http://example.org/o>. }.
-
-<http://example.org/s> <http://example.org/p> <http://example.org/o>.
-`;
-const out = reason({ proofComments: false }, input);
-if (!/<http:\/\/example\.org\/s>\s+<http:\/\/example\.org\/q>\s+<http:\/\/example\.org\/o>\s*\./.test(out)) {
-  console.error("Unexpected output:\n" + out);
-  process.exit(1);
-}
-NODE
-ok "API works"
-
-say "CLI smoke test"
-./node_modules/.bin/eyeling -v
-ok "CLI works"
-
-say "Examples test (installed package)"
-cd node_modules/eyeling/examples
-./test
-
-ok "packaged install smoke test passed"
-