eyeling 1.32.0 → 1.33.0

package/index.d.ts

@@ -1,286 +1,293 @@
-declare module 'eyeling' {
-  export type RdfJsTerm = import('@rdfjs/types').Term;
-  export type RdfJsNamedNode = import('@rdfjs/types').NamedNode;
-  export type RdfJsBlankNode = import('@rdfjs/types').BlankNode;
-  export type RdfJsVariable = import('@rdfjs/types').Variable;
-  export type RdfJsDefaultGraph = import('@rdfjs/types').DefaultGraph;
-  export type RdfJsLiteral = import('@rdfjs/types').Literal;
-  export type RdfJsQuad = import('@rdfjs/types').Quad;
-  export type RdfJsDataFactory = import('@rdfjs/types').DataFactory<RdfJsQuad> & {
-    variable(value: string): RdfJsVariable;
-  };
-
-  export interface EyelingPrefixEnv {
-    _type?: 'PrefixEnv';
-    map: Record<string, string>;
-    baseIri?: string;
-  }
-
-  export interface EyelingIri {
-    _type?: 'Iri';
-    value: string;
-  }
-
-  export interface EyelingLiteral {
-    _type?: 'Literal';
-    value: string;
-  }
-
-  export interface EyelingVar {
-    _type?: 'Var';
-    name: string;
-  }
-
-  export interface EyelingBlank {
-    _type?: 'Blank';
-    label: string;
-  }
-
-  export interface EyelingListTerm {
-    _type?: 'ListTerm';
-    elems: EyelingTerm[];
-  }
-
-  export interface EyelingOpenListTerm {
-    _type?: 'OpenListTerm';
-    prefix: EyelingTerm[];
-    tailVar: string;
-  }
-
-  export interface EyelingGraphTerm {
-    _type?: 'GraphTerm';
-    triples: EyelingTriple[];
-  }
-
-  export type EyelingTerm =
-    | EyelingIri
-    | EyelingLiteral
-    | EyelingVar
-    | EyelingBlank
-    | EyelingListTerm
-    | EyelingOpenListTerm
-    | EyelingGraphTerm
-    | RdfJsNamedNode
-    | RdfJsBlankNode
-    | RdfJsVariable
-    | RdfJsLiteral
-    | RdfJsQuad;
-
-  export interface EyelingTriple {
-    _type?: 'Triple';
-    s: EyelingTerm;
-    p: EyelingTerm;
-    o: EyelingTerm;
-  }
-
-  export interface EyelingRule {
-    _type?: 'Rule';
-    premise: EyelingTriple[];
-    conclusion: EyelingTriple[];
-    isForward?: boolean;
-    isFuse?: boolean;
-    headBlankLabels?: Iterable<string> | string[];
-    __dynamicConclusionTerm?: EyelingTerm;
-  }
-
-  export type EyelingAstBundle = [EyelingPrefixEnv, EyelingTriple[], EyelingRule[], EyelingRule[], EyelingRule[]?];
-
-  export type N3Source = string | { n3?: string; text?: string; baseIri?: string; label?: string };
-
-  export interface N3SourceListInput {
-    sources: N3Source[];
-    scopeBlankNodes?: boolean;
-  }
-
-  export interface RdfJsReasonInput {
-    n3?: string;
-    quads?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
-    facts?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
-    dataset?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
-    rules?: EyelingRule[] | EyelingAstBundle;
-    factsN3?: string;
-    n3Facts?: string;
-    prefixesN3?: string;
-    n3Prefixes?: string;
-    prefixes?: EyelingPrefixEnv;
-    triples?: EyelingTriple[];
-    forwardRules?: EyelingRule[];
-    frules?: EyelingRule[];
-    backwardRules?: EyelingRule[];
-    brules?: EyelingRule[];
-    queryRules?: EyelingRule[];
-    logQueryRules?: EyelingRule[];
-    qrules?: EyelingRule[];
-    ast?: EyelingAstBundle;
-    document?: EyelingAstBundle;
-  }
-
-  export interface StoreOptions {
-    name?: string;
-    clear?: boolean;
-    path?: string;
-    type?: 'memory' | 'persistent';
-    backend?: 'memory' | 'level' | 'indexeddb';
-  }
-
-  export interface ReasonOptions {
-    proof?: boolean;
-    proofComments?: boolean;
-    noProofComments?: boolean;
-    args?: string[];
-    maxBuffer?: number;
-    builtinModules?: string | string[];
-    store?: string | StoreOptions;
-    storePath?: string;
-    storeClear?: boolean;
-  }
-
-  export interface BuiltinRegistrationContext {
-    iri: string;
-    goal: EyelingTriple;
-    subst: Record<string, EyelingTerm>;
-    facts: any[];
-    backRules: EyelingRule[];
-    depth: number;
-    varGen: number[];
-    maxResults?: number;
-    api: any;
-  }
-
-  export type BuiltinHandler = (ctx: BuiltinRegistrationContext) => Array<Record<string, EyelingTerm>>;
-
-  export interface ReasonStreamOptions {
-    baseIri?: string | null;
-    proof?: boolean;
-    includeInputFactsInClosure?: boolean;
-    enforceHttps?: boolean;
-    rdfjs?: boolean;
-    dataFactory?: RdfJsDataFactory | null;
-    skipUnsupportedRdfJs?: boolean;
-    builtinModules?: string | string[];
-    store?: string | StoreOptions;
-    storePath?: string;
-    storeClear?: boolean;
-    onDerived?: (item: { triple: string; quad?: RdfJsQuad; quads?: RdfJsQuad[]; df: any }) => void;
-  }
-
-  export interface ReasonStreamResult {
-    prefixes: any;
-    facts: any[];
-    derived: any[];
-    queryMode: boolean;
-    queryTriples: any[];
-    queryDerived: any[];
-    closureN3: string;
-    closureQuads?: RdfJsQuad[];
-    queryQuads?: RdfJsQuad[];
-  }
-
-  export interface FactStore {
-    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
-    has(triple: EyelingTriple): Promise<boolean>;
-    kindOf?(triple: EyelingTriple): Promise<number>;
-    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
-    batchAdd?(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
-    clear?(): Promise<void>;
-    close?(): Promise<void>;
-  }
-
-  export class MemoryFactStore implements FactStore {
-    constructor();
-    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
-    has(triple: EyelingTriple): Promise<boolean>;
-    kindOf(triple: EyelingTriple): Promise<number>;
-    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
-    batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
-    clear(): Promise<void>;
-    close(): Promise<void>;
-  }
-
-  export class PersistentFactStore implements FactStore {
-    add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
-    has(triple: EyelingTriple): Promise<boolean>;
-    kindOf(triple: EyelingTriple): Promise<number>;
-    match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
-    batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
-    clear(): Promise<void>;
-    close(): Promise<void>;
-  }
-
-  export function reason(
-    opts: ReasonOptions,
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-  ): string;
-  export function runAsync(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: ReasonStreamOptions,
-  ): Promise<ReasonStreamResult & { store?: FactStore }>;
-  export function reasonStream(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: ReasonStreamOptions,
-  ): ReasonStreamResult;
-  export function reasonRdfJs(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
-  ): AsyncIterable<RdfJsQuad>;
-
-  export const INFERENCE_FUSE_EXIT_CODE: 65;
-  export const rdfjs: RdfJsDataFactory;
-  export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
-  export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
-  export function unregisterBuiltin(iri: string): boolean;
-  export function registerBuiltinModule(mod: any, origin?: string): boolean;
-  export function loadBuiltinModule(specifier: string, options?: { resolveFrom?: string }): string;
-  export function listBuiltinIris(): string[];
+export interface EyelingPrefixEnv {
+  _type?: 'PrefixEnv';
+  map: Record<string, string>;
+  baseIri?: string;
 }
 
-declare module 'eyeling/browser' {
-  export type RdfJsDataFactory = import('eyeling').RdfJsDataFactory;
-  export type RdfJsQuad = import('eyeling').RdfJsQuad;
-  export type RdfJsReasonInput = import('eyeling').RdfJsReasonInput;
-  export type EyelingAstBundle = import('eyeling').EyelingAstBundle;
-  export type N3Source = import('eyeling').N3Source;
-  export type N3SourceListInput = import('eyeling').N3SourceListInput;
-  export type ReasonStreamOptions = import('eyeling').ReasonStreamOptions;
-  export type ReasonStreamResult = import('eyeling').ReasonStreamResult;
-  export type BuiltinHandler = import('eyeling').BuiltinHandler;
-  export type StoreOptions = import('eyeling').StoreOptions;
-  export type FactStore = import('eyeling').FactStore;
-
-  export function runAsync(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: ReasonStreamOptions,
-  ): Promise<ReasonStreamResult & { store?: FactStore }>;
-  export function reasonStream(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: ReasonStreamOptions,
-  ): ReasonStreamResult;
-  export function reasonRdfJs(
-    input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
-    opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
-  ): AsyncIterable<RdfJsQuad>;
-
-  export const INFERENCE_FUSE_EXIT_CODE: 65;
-  export const rdfjs: RdfJsDataFactory;
-  export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
-  export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
-  export function unregisterBuiltin(iri: string): boolean;
-  export function registerBuiltinModule(mod: any, origin?: string): boolean;
-  export function listBuiltinIris(): string[];
-
-  const eyeling: {
-    readonly version: string;
-    runAsync: typeof runAsync;
-    reasonStream: typeof reasonStream;
-    reasonRdfJs: typeof reasonRdfJs;
-    readonly INFERENCE_FUSE_EXIT_CODE: typeof INFERENCE_FUSE_EXIT_CODE;
-    rdfjs: typeof rdfjs;
-    createFactStore: typeof createFactStore;
-    registerBuiltin: typeof registerBuiltin;
-    unregisterBuiltin: typeof unregisterBuiltin;
-    registerBuiltinModule: typeof registerBuiltinModule;
-    listBuiltinIris: typeof listBuiltinIris;
-  };
-
-  export default eyeling;
+export interface EyelingIri {
+  _type?: 'Iri';
+  value: string;
 }
+
+export interface EyelingLiteral {
+  _type?: 'Literal';
+  value: string;
+}
+
+export interface EyelingVar {
+  _type?: 'Var';
+  name: string;
+}
+
+export interface EyelingBlank {
+  _type?: 'Blank';
+  label: string;
+}
+
+export interface EyelingListTerm {
+  _type?: 'ListTerm';
+  elems: EyelingTerm[];
+}
+
+export interface EyelingOpenListTerm {
+  _type?: 'OpenListTerm';
+  prefix: EyelingTerm[];
+  tailVar: string;
+}
+
+export interface EyelingGraphTerm {
+  _type?: 'GraphTerm';
+  triples: EyelingTriple[];
+}
+
+export type EyelingTerm =
+  | EyelingIri
+  | EyelingLiteral
+  | EyelingVar
+  | EyelingBlank
+  | EyelingListTerm
+  | EyelingOpenListTerm
+  | EyelingGraphTerm
+  | import('@rdfjs/types').NamedNode
+  | import('@rdfjs/types').BlankNode
+  | import('@rdfjs/types').Variable
+  | import('@rdfjs/types').Literal
+  | import('@rdfjs/types').Quad;
+
+export interface EyelingTriple {
+  _type?: 'Triple';
+  s: EyelingTerm;
+  p: EyelingTerm;
+  o: EyelingTerm;
+}
+
+export interface EyelingRule {
+  _type?: 'Rule';
+  premise: EyelingTriple[];
+  conclusion: EyelingTriple[];
+  isForward?: boolean;
+  isFuse?: boolean;
+  headBlankLabels?: Iterable<string> | string[];
+  __dynamicConclusionTerm?: EyelingTerm;
+}
+
+export type EyelingAstBundle = [EyelingPrefixEnv, EyelingTriple[], EyelingRule[], EyelingRule[], EyelingRule[]?];
+
+export type N3Source = string | { n3?: string; text?: string; baseIri?: string; label?: string };
+
+export interface N3SourceListInput {
+  sources: N3Source[];
+  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;
+  rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  args?: string[];
+  maxBuffer?: number;
+  [key: string]: unknown;
+}
+
+export interface EyelangRunResult {
+  stdout: string;
+  stats: EyelangStats;
+}
+
+export interface RdfJsReasonInput {
+  n3?: string;
+  quads?: Iterable<import('@rdfjs/types').Quad> | AsyncIterable<import('@rdfjs/types').Quad>;
+  facts?: Iterable<import('@rdfjs/types').Quad> | AsyncIterable<import('@rdfjs/types').Quad>;
+  dataset?: Iterable<import('@rdfjs/types').Quad> | AsyncIterable<import('@rdfjs/types').Quad>;
+  rules?: EyelingRule[] | EyelingAstBundle;
+  factsN3?: string;
+  n3Facts?: string;
+  prefixesN3?: string;
+  n3Prefixes?: string;
+  prefixes?: EyelingPrefixEnv;
+  triples?: EyelingTriple[];
+  forwardRules?: EyelingRule[];
+  frules?: EyelingRule[];
+  backwardRules?: EyelingRule[];
+  brules?: EyelingRule[];
+  queryRules?: EyelingRule[];
+  logQueryRules?: EyelingRule[];
+  qrules?: EyelingRule[];
+  ast?: EyelingAstBundle;
+  document?: EyelingAstBundle;
+}
+
+export interface StoreOptions {
+  name?: string;
+  clear?: boolean;
+  path?: string;
+  type?: 'memory' | 'persistent';
+  backend?: 'memory' | 'level' | 'indexeddb';
+}
+
+export interface ReasonOptions {
+  engine?: EngineName;
+  proof?: boolean;
+  proofComments?: boolean;
+  noProofComments?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  stats?: boolean;
+  rdf?: boolean;
+  rdf12?: boolean;
+  n3?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  args?: string[];
+  maxBuffer?: number;
+  builtinModules?: string | string[];
+  store?: string | StoreOptions;
+  storePath?: string;
+  storeClear?: boolean;
+}
+
+export interface BuiltinRegistrationContext {
+  iri: string;
+  goal: EyelingTriple;
+  subst: Record<string, EyelingTerm>;
+  facts: EyelingTriple[];
+  backRules: EyelingRule[];
+  depth: number;
+  varGen: number[];
+  maxResults?: number;
+  api: unknown;
+}
+
+export type BuiltinHandler = (ctx: BuiltinRegistrationContext) => Array<Record<string, EyelingTerm>>;
+
+export interface ReasonStreamOptions {
+  engine?: EngineName;
+  baseIri?: string | null;
+  proof?: boolean;
+  includeInputFactsInClosure?: boolean;
+  enforceHttps?: boolean;
+  rdfjs?: boolean;
+  dataFactory?: import('@rdfjs/types').DataFactory<import('@rdfjs/types').Quad, import('@rdfjs/types').Quad> | null;
+  skipUnsupportedRdfJs?: boolean;
+  builtinModules?: string | string[];
+  store?: string | StoreOptions;
+  storePath?: string;
+  storeClear?: boolean;
+  onDerived?: (item: { triple: string; quad?: import('@rdfjs/types').Quad; quads?: import('@rdfjs/types').Quad[]; df: import('@rdfjs/types').DataFactory<import('@rdfjs/types').Quad, import('@rdfjs/types').Quad> }) => void;
+}
+
+export interface ReasonStreamResult {
+  prefixes: EyelingPrefixEnv;
+  facts: EyelingTriple[];
+  derived: EyelingTriple[];
+  queryMode: boolean;
+  queryTriples: EyelingTriple[];
+  queryDerived: EyelingTriple[];
+  closureN3: string;
+  closureQuads?: import('@rdfjs/types').Quad[];
+  queryQuads?: import('@rdfjs/types').Quad[];
+}
+
+export interface FactStore {
+  add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+  has(triple: EyelingTriple): Promise<boolean>;
+  kindOf?(triple: EyelingTriple): Promise<number>;
+  match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+  batchAdd?(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+  clear?(): Promise<void>;
+  close?(): Promise<void>;
+}
+
+export class MemoryFactStore implements FactStore {
+  constructor();
+  add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+  has(triple: EyelingTriple): Promise<boolean>;
+  kindOf(triple: EyelingTriple): Promise<number>;
+  match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+  batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+  clear(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export class PersistentFactStore implements FactStore {
+  constructor(kv?: unknown, options?: StoreOptions);
+  add(triple: EyelingTriple, kind?: 'explicit' | 'inferred'): Promise<boolean>;
+  has(triple: EyelingTriple): Promise<boolean>;
+  kindOf(triple: EyelingTriple): Promise<number>;
+  match(s?: EyelingTerm | null, p?: EyelingTerm | null, o?: EyelingTerm | null): AsyncIterable<EyelingTriple>;
+  batchAdd(triples: Iterable<EyelingTriple>, kind?: 'explicit' | 'inferred'): Promise<number>;
+  clear(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export function reason(
+  opts: ReasonOptions,
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput | EyelangSourceListInput,
+): 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,
+): ReasonStreamResult;
+export function reasonRdfJs(
+  input: string | RdfJsReasonInput | EyelingAstBundle | N3SourceListInput,
+  opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
+): AsyncIterable<import('@rdfjs/types').Quad>;
+
+export const INFERENCE_FUSE_EXIT_CODE: 65;
+export const rdfjs: import('@rdfjs/types').DataFactory<import('@rdfjs/types').Quad, import('@rdfjs/types').Quad> & { variable(value: string): import('@rdfjs/types').Variable };
+export function createFactStore(options?: string | StoreOptions | null): Promise<FactStore>;
+export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
+export function unregisterBuiltin(iri: string): boolean;
+export function registerBuiltinModule(mod: unknown, origin?: string): boolean;
+export function loadBuiltinModule(specifier: string, options?: { resolveFrom?: string }): string;
+export function listBuiltinIris(): string[];
+
+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;
+  rdfjs: typeof rdfjs;
+  createFactStore: typeof createFactStore;
+  MemoryFactStore: typeof MemoryFactStore;
+  PersistentFactStore: typeof PersistentFactStore;
+  registerBuiltin: typeof registerBuiltin;
+  unregisterBuiltin: typeof unregisterBuiltin;
+  registerBuiltinModule: typeof registerBuiltinModule;
+  loadBuiltinModule: typeof loadBuiltinModule;
+  listBuiltinIris: typeof listBuiltinIris;
+}
+
+declare const eyeling: EyelingModule;
+export default eyeling;

package/index.js

@@ -4,12 +4,100 @@ 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');
 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
+            : typeof source.n3 === 'string' ? source.n3
+              : 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 (opt.rdf || opt.rdf12) args.push('--rdf');
+  if (opt.n3) args.push('--n3');
+  if (typeof opt.inputFormat === 'string' && opt.inputFormat) args.push('--input-format', opt.inputFormat);
+  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.mjs')).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 = '';
 
@@ -17,6 +105,8 @@ 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)
@@ -116,12 +206,16 @@ function reason(opt = {}, input = '') {
 }
 
 async function runAsync(input = '', opt = {}) {
-  return engine.runAsync(input, opt || {});
+  const options = opt || {};
+  if (normalizeEngineName(options.engine) === 'eyelang') return runEyelang(input, options);
+  return engine.runAsync(input, options);
 }
 
 module.exports = {
   reason,
   runAsync,
+  runEyelang,
+  reasonEyelang,
   reasonStream: bundleApi.reasonStream,
   reasonRdfJs: bundleApi.reasonRdfJs,
   rdfjs: dataFactory,