eyeprolog 1.3.65 → 1.3.67

package/src/program.js

@@ -1,6 +1,6 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, STRING, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
+import { ATOM, COMPOUND, NUMBER, STRING, VAR, Env, atom, compound, deref, flattenConjunction, isScalar, numberTerm, properListItems, termToString, variable } from './term.js';
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
@@ -1195,6 +1195,19 @@ function moduleExportIndicators(term) {
   if (items == null) return null;
   const indicators = [];
   for (const item of items) {
+    // Scryer-style modules may export operators alongside predicate
+    // indicators, for example op(700, xfx, #=) from library(clpz).
+    // Operator visibility while parsing bundled libraries is handled by the
+    // parser's imported-library operator table; module import resolution only
+    // needs procedure indicators here.
+    if (item.type === COMPOUND && item.name === 'op' && item.arity === 3) {
+      const [priority, specifier, names] = item.args;
+      const operatorNames = names.type === ATOM ? [names] : properListItems(names, new Env());
+      if (priority.type !== NUMBER || !/^\d+$/.test(priority.name) || Number(priority.name) > 1200 ||
+          specifier.type !== ATOM || !['fx', 'fy', 'xf', 'yf', 'xfx', 'xfy', 'yfx'].includes(specifier.name) ||
+          operatorNames == null || operatorNames.some((name) => name.type !== ATOM)) return null;
+      continue;
+    }
     if (item.type !== COMPOUND || !['/', '//'].includes(item.name) || item.arity !== 2) return null;
     const indicator = predicateIndicator(item.args[0], item.args[1]);
     if (!indicator) return null;

package/src/repl.js

@@ -740,6 +740,37 @@ function formatAnswer(engine, state, variables, env) {
       doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     })}`);
   }
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    const residual = constraint.residualGoal?.(env);
+    if (residual == null) continue;
+    collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+    bindings.push(engine.formatTermForWrite(residual, env, {
+      quoted: true,
+      operators,
+      variableNames: names,
+      operatorAtomsAsArgs: true,
+      dottedGraphicAtoms: true,
+      doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    }));
+  }
+  const projectedAttributeRoots = new Set();
+  for (const variable of variables) {
+    const root = engine.deref(variable, env);
+    if (root.type !== 'var' || projectedAttributeRoots.has(root.name) || !env.hasPrologAttributes?.(root.name)) continue;
+    projectedAttributeRoots.add(root.name);
+    names.set(root.name, variable.name);
+    for (const residual of state.solver.attributeResidualGoals(root, env)) {
+      collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
+      bindings.push(engine.formatTermForWrite(residual, env, {
+        quoted: true,
+        operators,
+        variableNames: names,
+        operatorAtomsAsArgs: true,
+        dottedGraphicAtoms: true,
+        doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+      }));
+    }
+  }
   return bindings.length === 0 ? 'true' : bindings.join(', ');
 }
 

package/src/solver.js

@@ -3,7 +3,7 @@
 import {
   ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
-  numberTerm, numberTextFromDouble, termIsGround, termToString, unify, variable, variantTerms,
+  numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
 import { PrologError, getStrictIsoRegistry } from './iso.js';
@@ -32,6 +32,23 @@ function qualifyTerm(term, module) {
   return term;
 }
 
+function renameVariableInTerm(term, fromName, toName) {
+  if (fromName === toName) return term;
+  const stack = [term];
+  const seen = new Set();
+  while (stack.length) {
+    const current = stack.pop();
+    if (current == null || seen.has(current)) continue;
+    seen.add(current);
+    if (current.type === VAR) {
+      if (current.name === fromName) current.name = toName;
+      continue;
+    }
+    if (current.type === COMPOUND) for (const arg of current.args) stack.push(arg);
+  }
+  return term;
+}
+
 export function nextFreshId() {
   return ++freshCounter;
 }
@@ -120,6 +137,8 @@ export class Solver {
         raiseOccursCheckError(left, right, env);
       }
     };
+    this.attributeHookRunner = (module, attributed, other, env) =>
+      this.runAttributeHook(module, attributed, other, env);
     this.charConversions = options.charConversions ?? new Map();
     if (!options.prologFlags) {
       if (['chars', 'codes', 'atom'].includes(program.doubleQuotes)) {
@@ -303,6 +322,54 @@ export class Solver {
     }
   }
 
+  runAttributeHook(module, attributed, other, env) {
+    if (this.program.findGroup('verify_attributes', 3, module) == null) return true;
+    const goalsVariable = variable(`\u0000attributeGoals${nextFreshId()}`);
+    const hook = compound('verify_attributes', [attributed, other, goalsVariable]);
+    qualifyTerm(hook, module);
+    const child = this.cloneForInnerGoal(1);
+    const iterator = child.solve([hook], env.clone(), 0);
+    const result = iterator.next();
+    try { iterator.return?.(); } catch (_) { /* best-effort iterator cleanup */ }
+    this.absorbStatsFrom(child);
+    if (result.done) return false;
+    env.adopt(result.value);
+    env.setOccursCheckHandler(this.occursCheckHandler);
+    env.setAttributeHookRunner(this.attributeHookRunner);
+    const goals = properListItems(goalsVariable, env);
+    if (goals == null) throw new PrologError('type_error(list)', deref(goalsVariable, env));
+    for (const goal of goals) qualifyTerm(goal, module);
+    env.enqueueAttributeGoals(goals);
+    return true;
+  }
+
+  attributeResidualGoals(variableTerm, env) {
+    const root = deref(variableTerm, env);
+    if (root.type !== VAR || !env.hasPrologAttributes(root.name)) return [];
+    const residuals = [];
+    for (const module of env.prologAttributeModules(root.name)) {
+      if (this.program.findGroup('attribute_goals', 3, module) == null) continue;
+      const goalsVariable = variable(`\u0000attributeResidual${nextFreshId()}`);
+      const projection = compound('attribute_goals', [root, goalsVariable, emptyList()]);
+      qualifyTerm(projection, module);
+      const child = this.cloneForInnerGoal(1);
+      const iterator = child.solve([projection], env.clone(), 0);
+      const result = iterator.next();
+      try { iterator.return?.(); } catch (_) { /* best-effort iterator cleanup */ }
+      this.absorbStatsFrom(child);
+      if (result.done) continue;
+      const goals = properListItems(goalsVariable, result.value);
+      if (goals == null) throw new PrologError('type_error(list)', deref(goalsVariable, result.value));
+      const projectedRoot = deref(root, result.value);
+      for (const goal of goals) {
+        const residual = copyResolved(goal, result.value);
+        if (projectedRoot.type === VAR) renameVariableInTerm(residual, projectedRoot.name, root.name);
+        residuals.push(residual);
+      }
+    }
+    return residuals;
+  }
+
   runInitializations() {
     if (this.program._initializationsExecuted) return;
     for (const goal of this.program.initializations ?? []) {
@@ -321,6 +388,7 @@ export class Solver {
   *solve(goals, env = new Env(), depth = 0) {
     if (!Array.isArray(goals)) goals = [goals];
     env.setOccursCheckHandler(this.occursCheckHandler);
+    env.setAttributeHookRunner(this.attributeHookRunner);
     if (this.isoStrict) rejectStrictIsoStringTerms(goals, env);
 
     const writeVariableState = this.writeVariableState;
@@ -386,6 +454,7 @@ export class Solver {
       goals = frame.goals;
       env = frame.env;
       env.setOccursCheckHandler(this.occursCheckHandler);
+      env.setAttributeHookRunner(this.attributeHookRunner);
       depth = frame.depth;
       let active = frame.active;
 
@@ -408,6 +477,9 @@ export class Solver {
         }
         if (this.solutionsSeen >= this.solutionLimit) break;
 
+        const pendingAttributeGoals = env.takePendingAttributeGoals?.() ?? [];
+        if (pendingAttributeGoals.length > 0) goals = [...pendingAttributeGoals, ...goals];
+
         const readyDelays = env.takeReadyDelays();
         if (readyDelays.length > 0) {
           const awakened = readyDelays.map(({ goal, module }) => {
@@ -1971,7 +2043,7 @@ function fastCountBranch(branch, env) {
 
 function fastCountPureGoal(solver, goal, env) {
   if (solver.isoStrict || solver.solutionLimit !== Infinity || solver.maxInferences !== Infinity ||
-      env._clpz != null || (env._delays != null && env._delays.size !== 0)) return null;
+      env._clpz != null || env._variableConstraints != null || env._prologAttributes != null || (env._delays != null && env._delays.size !== 0)) return null;
   const budget = { remaining: 8192 };
   const branches = expandPureCountGoal(solver, goal, goal.module ?? 'user', new Set(), budget);
   if (branches == null) return null;
@@ -1981,6 +2053,7 @@ function fastCountPureGoal(solver, goal, env) {
 }
 
 function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
+  if (env._prologAttributes != null) return false;
   // Consecutive scalar-fact lookups are common in data-heavy joins.  Short
   // joins are fastest when their continuation frames are materialized locally;
   // wide joins can explode combinatorially, so they are streamed lazily.
@@ -2015,6 +2088,7 @@ function tryPushScalarFactRunFrames(stack, solver, goals, env, depth, active) {
     if (state.index === runLength) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
       frames.push({ kind: 'goals', goals: rest, env: next, depth: state.depth, active });
       if (frames.length > frameLimit) {
         // Do not repeat the old bug of abandoning the optimization and then
@@ -2079,6 +2153,7 @@ function* scalarFactRunSolutions(solver, goals, groups, env, depth, active) {
     if (state.index === goals.length) {
       const next = env.clone();
       for (let i = 0; i < state.names.length; i++) next.bind(state.names[i], state.values[i]);
+      if (next._variableConstraints != null && !next.validateVariableConstraints()) continue;
       yield next;
       continue;
     }
@@ -2162,6 +2237,11 @@ function matchScalarFactLocal(goal, head, env, names, values) {
 }
 
 function matchScalarFact(goal, head, env) {
+  if (env._prologAttributes != null) {
+    const next = env.clone();
+    if (!unify(goal, head, next)) return null;
+    return next;
+  }
   // A scalar ground fact has no variables to freshen and no compound structure
   // to traverse. Match the goal arguments directly and clone only after the
   // candidate has succeeded.
@@ -2183,6 +2263,7 @@ function matchScalarFact(goal, head, env) {
 
   const next = env.clone();
   for (let i = 0; i < names.length; i++) next.bind(names[i], values[i]);
+  if (next._variableConstraints != null && !next.validateVariableConstraints()) return null;
   return next;
 }
 

package/src/standard-library.js

@@ -4,12 +4,14 @@
 // source-level interop autoloader declared below.
 import { PrologError, createDefaultRegistry, eyePrologLibraryBuiltins } from './iso.js';
 import { clpzBuiltins } from './clpz.js';
+import { attsBuiltins } from './atts.js';
 import { registerCleanupBuiltins } from './cleanup.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
 import { ATOM, VAR, atom, deref, numberTerm, unify } from './term.js';
 
 const moduleFiles = Object.freeze({
   aggregate: 'aggregate.pl',
+  atts: 'atts.pl',
   clpz: 'clpz.pl',
   comparison: 'comparison.pl',
   dates: 'dates.pl',
@@ -48,7 +50,8 @@ function libraryUrl(filename) {
 }
 
 export const eyePrologNativeLibraryIndicators = Object.freeze([
-  'call_nth/2', 'freeze/2', 'countall/2', 'time/1',
+  'call_nth/2', 'freeze/2', 'dif/2', 'countall/2', 'time/1',
+  'put_atts/2', 'get_atts/2', 'put_attr/3', 'get_attr/3', 'del_attr/2', 'term_attributed_variables/2',
   '#>/2', '#</2', '#>=/2', '#=</2', '#=/2', '#\\=/2', '#\\/1',
   '#<==>/2', '#==>/2', '#<==/2', '#\\//2', '#\\/2', '#/\\/2',
   'in/2', 'ins/2', 'all_different/1', 'all_distinct/1', 'nvalue/2', 'sum/3',
@@ -137,7 +140,7 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 // Libraries whose *name* is part of the current interop profile.  A program
 // may freely use_module/1 with these common module names; predicates in those
 // modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda']);
+export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda', 'atts']);
 
 function* tabledNegationBuiltin({ solver, goal, env }) {
   yield* solver.solveTabledNegation(goal.args[0], env);
@@ -184,6 +187,7 @@ export function createEyePrologRegistry() {
   registry.add('tnot', 1, tabledNegationBuiltin, { deterministic: true });
   registerCleanupBuiltins(registry);
   eyePrologLibraryBuiltins.register(registry);
+  attsBuiltins.register(registry);
   clpzBuiltins.register(registry);
   registry.eyePrologLibrary = true;
   return registry;

package/src/term.js

@@ -97,6 +97,18 @@ export class Env {
       cache: null,
     };
     this._delays = null;
+    // Backtracking-safe attributed-variable constraints. Constraints are
+    // immutable descriptors shared by cloned environments; the Set/Map index
+    // is copied only when a branch adds, removes, or reindexes a constraint.
+    this._variableConstraints = null;
+    this._variableAnnotations = null;
+    // Prolog-visible attributed variables. The outer map is indexed by the
+    // current unbound representative name; each representative owns module-
+    // scoped attribute terms keyed by functor/arity. Maps are copy-on-write so
+    // Env.clone() keeps ordinary Prolog backtracking constant-time.
+    this._prologAttributes = null;
+    this._attributeHookRunner = null;
+    this._pendingAttributeGoals = null;
     this._clpz = null;
     this._occursCheckHandler = null;
     this._localVariables = null;
@@ -110,6 +122,11 @@ export class Env {
     const clone = Object.create(Env.prototype);
     clone._state = this._state;
     clone._delays = this._delays;
+    clone._variableConstraints = this._variableConstraints;
+    clone._variableAnnotations = this._variableAnnotations;
+    clone._prologAttributes = this._prologAttributes;
+    clone._attributeHookRunner = this._attributeHookRunner;
+    clone._pendingAttributeGoals = this._pendingAttributeGoals;
     clone._clpz = this._clpz;
     clone._occursCheckHandler = this._occursCheckHandler;
     clone._localVariables = this._localVariables;
@@ -119,6 +136,24 @@ export class Env {
     this._occursCheckHandler = typeof handler === 'function' ? handler : null;
     return this;
   }
+  setAttributeHookRunner(handler) {
+    this._attributeHookRunner = typeof handler === 'function' ? handler : null;
+    return this;
+  }
+  adopt(other) {
+    if (!(other instanceof Env)) throw new TypeError('Env.adopt expects Env');
+    this._state = other._state;
+    this._delays = other._delays;
+    this._variableConstraints = other._variableConstraints;
+    this._variableAnnotations = other._variableAnnotations;
+    this._prologAttributes = other._prologAttributes;
+    this._pendingAttributeGoals = other._pendingAttributeGoals;
+    this._clpz = other._clpz;
+    // Execution callbacks belong to the Solver driving this Env, not to the
+    // logical branch being adopted from an inner attribute-hook call.
+    this._localVariables = other._localVariables;
+    return this;
+  }
   hasLocalVariables() {
     return this._localVariables != null && this._localVariables.size !== 0;
   }
@@ -236,6 +271,198 @@ export class Env {
     if (ready.length > 0) this._delays = remaining;
     return ready;
   }
+  _attributeRootName(name) {
+    const root = deref(variable(name), this);
+    return root.type === VAR ? root.name : null;
+  }
+  _attributeModulesForRoot(name) {
+    const root = this._attributeRootName(name);
+    return root == null ? null : (this._prologAttributes?.get(root) ?? null);
+  }
+  prologAttributes(name, module = null) {
+    const modules = this._attributeModulesForRoot(name);
+    if (modules == null) return [];
+    if (module != null) return [...(modules.get(module)?.values() ?? [])];
+    const result = [];
+    for (const [owner, attrs] of modules) {
+      for (const attribute of attrs.values()) result.push({ module: owner, attribute });
+    }
+    return result;
+  }
+  prologAttributeModules(name) {
+    const modules = this._attributeModulesForRoot(name);
+    return modules == null ? [] : [...modules.keys()];
+  }
+  getPrologAttribute(name, module, functor, arity) {
+    const modules = this._attributeModulesForRoot(name);
+    return modules?.get(module)?.get(`${functor}/${arity}`) ?? null;
+  }
+  putPrologAttribute(name, module, attribute) {
+    const root = this._attributeRootName(name);
+    if (root == null) return false;
+    const signature = `${attribute.name}/${attribute.arity}`;
+    const outer = new Map(this._prologAttributes ?? []);
+    const modules = new Map(outer.get(root) ?? []);
+    const attrs = new Map(modules.get(module) ?? []);
+    attrs.set(signature, attribute);
+    modules.set(module, attrs);
+    outer.set(root, modules);
+    this._prologAttributes = outer;
+    return true;
+  }
+  deletePrologAttribute(name, module, functor, arity = null) {
+    const root = this._attributeRootName(name);
+    if (root == null) return false;
+    const existingModules = this._prologAttributes?.get(root);
+    const existingAttrs = existingModules?.get(module);
+    if (existingAttrs == null) return false;
+    const attrs = new Map(existingAttrs);
+    let deleted = false;
+    if (arity == null) {
+      for (const key of [...attrs.keys()]) {
+        if (key.startsWith(`${functor}/`)) { attrs.delete(key); deleted = true; }
+      }
+    } else {
+      deleted = attrs.delete(`${functor}/${arity}`);
+    }
+    if (!deleted) return false;
+    const modules = new Map(existingModules);
+    if (attrs.size === 0) modules.delete(module); else modules.set(module, attrs);
+    const outer = new Map(this._prologAttributes);
+    if (modules.size === 0) outer.delete(root); else outer.set(root, modules);
+    this._prologAttributes = outer.size === 0 ? null : outer;
+    return true;
+  }
+  hasPrologAttributes(name) {
+    const modules = this._attributeModulesForRoot(name);
+    if (modules == null) return false;
+    for (const attrs of modules.values()) if (attrs.size !== 0) return true;
+    return false;
+  }
+  attributedVariableNames() {
+    if (this._prologAttributes == null) return [];
+    const names = [];
+    const seen = new Set();
+    for (const name of this._prologAttributes.keys()) {
+      const root = deref(variable(name), this);
+      if (root.type !== VAR || seen.has(root.name)) continue;
+      if (!this.hasPrologAttributes(root.name)) continue;
+      seen.add(root.name);
+      names.push(root.name);
+    }
+    return names;
+  }
+  enqueueAttributeGoals(goals) {
+    if (goals == null || goals.length === 0) return;
+    this._pendingAttributeGoals = [...(this._pendingAttributeGoals ?? []), ...goals];
+  }
+  takePendingAttributeGoals() {
+    if (this._pendingAttributeGoals == null || this._pendingAttributeGoals.length === 0) return [];
+    const goals = this._pendingAttributeGoals;
+    this._pendingAttributeGoals = null;
+    return goals;
+  }
+  _ownerModules(name) {
+    const modules = this._attributeModulesForRoot(name);
+    return modules == null ? [] : [...modules.keys()];
+  }
+  _targetHasOwnerModule(name, module) {
+    return this._attributeModulesForRoot(name)?.has(module) === true;
+  }
+  preparePrologAttributeUnification(variableTerm, otherTerm) {
+    if (this._prologAttributes == null || variableTerm?.type !== VAR) return true;
+    const sourceRoot = deref(variableTerm, this);
+    if (sourceRoot.type !== VAR) return true;
+    const modules = this._ownerModules(sourceRoot.name);
+    if (modules.length === 0) return true;
+    const other = deref(otherTerm, this);
+    if (other.type === VAR) {
+      if (other.name === sourceRoot.name) return true;
+      // Aliasing an attributed variable with a plain variable is just a
+      // representative change. No user-level hook is needed; final aliasing
+      // moves the attributes to the surviving representative.
+      const hooks = modules.filter((module) => this._targetHasOwnerModule(other.name, module));
+      for (const module of hooks) {
+        if (this._attributeHookRunner && !this._attributeHookRunner(module, sourceRoot, other, this)) return false;
+      }
+      return true;
+    }
+    for (const module of modules) {
+      if (this._attributeHookRunner && !this._attributeHookRunner(module, sourceRoot, other, this)) return false;
+    }
+    return true;
+  }
+  finalizePrologAttributeAlias(sourceName, targetName) {
+    if (this._prologAttributes == null || sourceName === targetName) return;
+    const source = this._prologAttributes.get(sourceName);
+    if (source == null) return;
+    const outer = new Map(this._prologAttributes);
+    const target = new Map(outer.get(targetName) ?? []);
+    for (const [module, sourceAttrs] of source) {
+      const attrs = new Map(target.get(module) ?? []);
+      for (const [signature, attribute] of sourceAttrs) {
+        if (!attrs.has(signature)) attrs.set(signature, attribute);
+      }
+      target.set(module, attrs);
+    }
+    outer.delete(sourceName);
+    outer.set(targetName, target);
+    this._prologAttributes = outer;
+  }
+  dropPrologAttributes(name) {
+    if (this._prologAttributes == null) return;
+    const outer = new Map(this._prologAttributes);
+    outer.delete(name);
+    this._prologAttributes = outer.size === 0 ? null : outer;
+  }
+  addVariableConstraint(constraint) {
+    if (constraint == null || typeof constraint.variables !== 'function' ||
+        typeof constraint.status !== 'function') {
+      throw new TypeError('variable constraint requires variables(env) and status(env)');
+    }
+    const constraints = new Set(this._variableConstraints ?? []);
+    constraints.add(constraint);
+    this._variableConstraints = constraints;
+    this._reindexVariableConstraints();
+  }
+  variableConstraints(kind = null) {
+    const constraints = [...(this._variableConstraints ?? [])];
+    return kind == null ? constraints : constraints.filter((constraint) => constraint.kind === kind);
+  }
+  variableAnnotations(name) {
+    const root = deref(variable(name), this);
+    if (root.type !== VAR) return [];
+    return [...(this._variableAnnotations?.get(root.name) ?? [])];
+  }
+  validateVariableConstraints() {
+    if (this._variableConstraints == null || this._variableConstraints.size === 0) return true;
+    const pending = new Set();
+    for (const constraint of this._variableConstraints) {
+      const status = constraint.status(this);
+      if (status === 'violated') return false;
+      if (status !== 'entailed') pending.add(constraint);
+    }
+    this._variableConstraints = pending.size === 0 ? null : pending;
+    this._reindexVariableConstraints();
+    return true;
+  }
+  _reindexVariableConstraints() {
+    if (this._variableConstraints == null || this._variableConstraints.size === 0) {
+      this._variableAnnotations = null;
+      return;
+    }
+    const annotations = new Map();
+    for (const constraint of this._variableConstraints) {
+      for (const name of constraint.variables(this)) {
+        const root = deref(variable(name), this);
+        if (root.type !== VAR) continue;
+        const set = annotations.get(root.name) ?? new Set();
+        set.add(constraint);
+        annotations.set(root.name, set);
+      }
+    }
+    this._variableAnnotations = annotations.size === 0 ? null : annotations;
+  }
 }
 
 export function deref(term, env) {
@@ -319,6 +546,15 @@ export function unify(left, right, env, options = {}) {
 
     if (a.type === VAR && b.type === VAR && a.name === b.name) continue;
     if (a.type === VAR && b.type === VAR) {
+      if (env?._prologAttributes != null) {
+        if (!env.preparePrologAttributeUnification(a, b)) return false;
+        a = deref(a, env);
+        b = deref(b, env);
+        if (a.type !== VAR || b.type !== VAR || a.name === b.name) {
+          stack.push([a, b]);
+          continue;
+        }
+      }
       // For a compiler-generated DCG state handed directly to another
       // nonterminal, keep the local caller variable as representative. Ordinary
       // aliases retain the established direction and observable conventions.
@@ -326,9 +562,11 @@ export function unify(left, right, env, options = {}) {
         a.name.startsWith('\u0000dcg') && b.name.startsWith('\u0000dcg');
       if (aLocalDcg) {
         markCompactVariableBound(b);
+        env?.finalizePrologAttributeAlias?.(b.name, a.name);
         env.bind(b.name, a);
       } else {
         markCompactVariableBound(a);
+        env?.finalizePrologAttributeAlias?.(a.name, b.name);
         env.bind(a.name, b);
       }
       continue;
@@ -339,7 +577,14 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(a, b, env);
         return false;
       }
+      if (env?._prologAttributes != null && env.hasPrologAttributes(a.name)) {
+        if (!env.preparePrologAttributeUnification(a, b)) return false;
+        a = deref(a, env);
+        b = deref(b, env);
+        if (a.type !== VAR) { stack.push([a, b]); continue; }
+      }
       markCompactVariableBound(a);
+      env?.dropPrologAttributes?.(a.name);
       env.bind(a.name, b);
       if (aLocal) env.forgetLocalVariable(a.name);
       continue;
@@ -350,7 +595,14 @@ export function unify(left, right, env, options = {}) {
         occursCheckHandler?.(b, a, env);
         return false;
       }
+      if (env?._prologAttributes != null && env.hasPrologAttributes(b.name)) {
+        if (!env.preparePrologAttributeUnification(b, a)) return false;
+        b = deref(b, env);
+        a = deref(a, env);
+        if (b.type !== VAR) { stack.push([a, b]); continue; }
+      }
       markCompactVariableBound(b);
+      env?.dropPrologAttributes?.(b.name);
       env.bind(b.name, a);
       if (bLocal) env.forgetLocalVariable(b.name);
       continue;
@@ -373,6 +625,7 @@ export function unify(left, right, env, options = {}) {
 
     return false;
   }
+  if (options.skipVariableConstraints !== true && env?._variableConstraints != null && !env.validateVariableConstraints()) return false;
   return true;
 }