are-engine-core 1.0.0 → 1.0.1

package/README.md

@@ -1,40 +1,40 @@
-# are-core — Action Rule Event Engine
+# are-engine-core — Action Rule Event Engine
 
-Sıfır bağımlılık, hafif olay-kural-eylem motoru.
+Zero dependency, lightweight event-rule-action engine.
 
-Browser, Node.js, React, Vue, React Native, Electron — her JS/TS ortamında çalışır.
+Browser, Node.js, React, Vue, React Native, Electron — works in any JS/TS environment.
 
-> Bu paket, C# [ARE.Core](../ARE.Core/) motorunun JavaScript/TypeScript portudur.
-> Aynı mimari, aynı API, aynı davranış.
+> This package is the JavaScript/TypeScript port of the C# [ARE.Core](../ARE.Core/) engine.
+> Same architecture, same API, same behavior.
 
 ---
 
-## Kurulum
+## Installation
 
 ```bash
-npm install are-core
+npm install are-engine-core
 ```
 
-Build adımı yok. TypeScript tip tanımları dahil gelir.
+No build step required. TypeScript type definitions are included out of the box.
 
 ---
 
-## Hızlı Başlangıç
+## Quick Start
 
 ```javascript
-const { AreEngine, Rule } = require('are-core');
-// veya
-// import { AreEngine, Rule } from 'are-core';
+const { AreEngine, Rule } = require('are-engine-core');
+// or
+// import { AreEngine, Rule } from 'are-engine-core';
 
-// 1) Engine oluştur
+// 1) Create the engine
 const engine = new AreEngine();
 
-// 2) Action kaydet
+// 2) Register an action
 engine.registerAction('send_email', async (ctx, s) => {
-  console.log('Email gönderildi:', s.get('template'));
+  console.log('Email sent:', s.get('template'));
 });
 
-// 3) Kural tanımla
+// 3) Define a rule
 engine.addRule(
   Rule.create('vip_order')
     .on('order.created')
@@ -42,23 +42,23 @@ engine.addRule(
     .then('send_email', s => s.set('template', 'vip_welcome'))
 );
 
-// 4) Event fırlat
+// 4) Fire an event
 await engine.fire('order.created', e => e.set('total', 7500));
-// Çıktı: Email gönderildi: vip_welcome
+// Output: Email sent: vip_welcome
 ```
 
 ---
 
-## Detaylı Kullanım
+## Detailed Usage
 
-### Action Tanımlama — Obje ile
+### Defining an Action — Object-Based
 
 ```javascript
 const damageAction = {
   actionType: 'damage',
   execute: async (ctx, settings) => {
     const amount = settings.get('amount');
-    console.log(`${amount} hasar verildi!`);
+    console.log(`${amount} damage dealt!`);
     ctx.set('lastDamage', amount);
   }
 };
@@ -66,7 +66,7 @@ const damageAction = {
 engine.registerAction(damageAction);
 ```
 
-### Action Tanımlama — Inline
+### Defining an Action — Inline
 
 ```javascript
 engine.registerAction('log', async (ctx, s) => {
@@ -74,7 +74,7 @@ engine.registerAction('log', async (ctx, s) => {
 });
 ```
 
-### Kural Tanımlama — Fluent Builder
+### Defining a Rule — Fluent Builder
 
 ```javascript
 engine.addRule(
@@ -90,63 +90,63 @@ engine.addRule(
 );
 ```
 
-### Birden Fazla Event Dinleme
+### Listening to Multiple Events
 
 ```javascript
 Rule.create('license_warning')
   .on('app.started', 'license.checked')
   .when('expiring', (evt) => (evt.data.days_remaining ?? 999) <= 7)
   .then('show_notification', s => s
-    .set('title', 'Lisans Uyarısı')
-    .set('message', '7 gün kaldı!'))
+    .set('title', 'License Warning')
+    .set('message', '7 days remaining!'))
 ```
 
-### Koşul Tipleri
+### Condition Types
 
 ```javascript
-// Alan karşılaştırma (deklaratif)
+// Field comparison (declarative)
 .whenEquals('status', 'active')
 .whenGreaterThan('score', 100)
 .whenLessThan('stock', 10)
 .whenField('category', CompareOp.Contains, 'premium')
 .whenField('role', CompareOp.In, ['admin', 'moderator'])
 
-// Lambda (esnek)
+// Lambda (flexible)
 .when('custom_check', (evt, ctx) => {
   return evt.data.total > 1000 && ctx.get('user_type') === 'vip';
 })
 ```
 
-### MatchMode — Koşul Eşleşme Modları
+### MatchMode — Condition Matching Modes
 
 ```javascript
-const { MatchMode } = require('are-core');
+const { MatchMode } = require('are-engine-core');
 
-// Tüm koşullar doğru olmalı (AND) — varsayılan
+// All conditions must be true (AND) — default
 .withMatchMode(MatchMode.All)
 
-// En az bir koşul doğru olmalı (OR)
+// At least one condition must be true (OR)
 .withMatchMode(MatchMode.Any)
 
-// Hiçbir koşul doğru olmamalı (NOT)
+// No conditions should be true (NOT)
 .withMatchMode(MatchMode.None)
 
-// Tam olarak bir koşul doğru olmalı
+// Exactly one condition must be true
 .withMatchMode(MatchMode.ExactlyOne)
 ```
 
 ### Middleware
 
 ```javascript
-// Loglama
+// Logging middleware
 engine.use(0, async (ctx, next) => {
-  console.log('Event başladı:', ctx.currentEvent.eventType);
+  console.log('Event started:', ctx.currentEvent.eventType);
   const start = Date.now();
   await next();
-  console.log('Event bitti:', (Date.now() - start) + 'ms');
+  console.log('Event completed:', (Date.now() - start) + 'ms');
 });
 
-// Auth kontrolü
+// Auth middleware
 engine.use(-10, async (ctx, next) => {
   if (!ctx.get('isAuthenticated')) {
     ctx.stopPipeline = true;
@@ -156,27 +156,27 @@ engine.use(-10, async (ctx, next) => {
 });
 ```
 
-### Doğrudan Listener (Kural Olmadan)
+### Direct Listener (Without Rules)
 
 ```javascript
 engine.on('order.created', async (evt, ctx) => {
-  console.log('Sipariş:', evt.data.order_id);
+  console.log('Order received:', evt.data.order_id);
 });
 ```
 
-### Dinamik Kural Yönetimi
+### Dynamic Rule Management
 
 ```javascript
-// Tek kural
+// Individual rules
 engine.disableRule('seasonal_discount');
 engine.enableRule('seasonal_discount');
 engine.removeRule('old_rule');
 
-// Grup toplu
+// Entire groups
 engine.disableGroup('marketing');
 engine.enableGroup('marketing');
 
-// Runtime'da yeni kural ekle
+// Add a new rule at runtime
 engine.addRule(
   Rule.create('flash_sale')
     .inGroup('marketing')
@@ -186,17 +186,17 @@ engine.addRule(
 );
 ```
 
-### Akış Kontrolü
+### Flow Control
 
 ```javascript
-// Pipeline'ı tamamen durdur (sonraki kurallar çalışmaz)
+// Stop the entire pipeline (remaining rules will not execute)
 engine.registerAction('validate', async (ctx) => {
   if (!ctx.currentEvent.data.valid) {
     ctx.stopPipeline = true;
   }
 });
 
-// Sadece mevcut kuralın kalan action'larını atla
+// Skip only the remaining actions of the current rule
 engine.registerAction('conditional_skip', async (ctx) => {
   if (someCondition) {
     ctx.skipRemainingActions = true;
@@ -204,7 +204,7 @@ engine.registerAction('conditional_skip', async (ctx) => {
 });
 ```
 
-### Context — Action'lar Arası Veri Paylaşımı
+### Context — Sharing Data Between Actions
 
 ```javascript
 engine.registerAction('calculate', async (ctx) => {
@@ -216,35 +216,35 @@ engine.registerAction('apply_tax', async (ctx) => {
   ctx.set('totalWithTax', total * 1.18);
 });
 
-// İkisi aynı event'te sırayla çalışırsa, context üzerinden veri paylaşır
+// When both run sequentially in the same event, they share data via context
 ```
 
-### Sonuç Okuma
+### Reading Results
 
 ```javascript
 const result = await engine.fire('order.created', e => e.set('total', 7500));
 
-console.log('Tetiklenen:', result.firedRules.length);
-console.log('Atlanan:', result.skippedRules.length);
-console.log('Pipeline durdu mu:', result.pipelineStopped);
-console.log('Süre:', result.duration + 'ms');
+console.log('Fired:', result.firedRules.length);
+console.log('Skipped:', result.skippedRules.length);
+console.log('Pipeline stopped:', result.pipelineStopped);
+console.log('Duration:', result.duration + 'ms');
 
 result.firedRules.forEach(r => {
   console.log(`  ${r.ruleId} → ${r.executedActions.join(', ')}`);
 });
 
 result.skippedRules.forEach(r => {
-  console.log(`  ${r.ruleId} → sağlanmayan: ${r.failedConditions.join(', ')}`);
+  console.log(`  ${r.ruleId} → failed: ${r.failedConditions.join(', ')}`);
 });
 ```
 
 ---
 
-## React Kullanımı
+## React Usage
 
 ```jsx
-import { AreEngine, Rule, GameEvent, AreContext } from 'are-core';
-import { useRef, useState } from 'react';
+import { AreEngine, Rule, GameEvent, AreContext } from 'are-engine-core';
+import { useRef } from 'react';
 
 function useAreEngine(setup) {
   const engineRef = useRef(null);
@@ -263,7 +263,7 @@ function useAreEngine(setup) {
   return { fire, engine: engineRef.current };
 }
 
-// Kullanım
+// Usage
 function App() {
   const { fire } = useAreEngine((engine) => {
     engine.registerAction('toast', async (ctx, s) => {
@@ -274,45 +274,45 @@ function App() {
       Rule.create('big_order')
         .on('cart.checkout')
         .whenGreaterThan('total', 500)
-        .then('toast', s => s.set('message', '🎉 Kargo bedava!'))
+        .then('toast', s => s.set('message', 'Free shipping!'))
     );
   });
 
-  return <button onClick={() => fire('cart.checkout', { total: 700 })}>Ödeme;
+  return <button onClick={() => fire('cart.checkout', { total: 700 })}>Checkout</button>;
 }
 ```
 
 ---
 
-## Export Listesi
+## Export List
 
 ```javascript
 const {
-  AreEngine,      // Çekirdek motor
-  AreContext,      // Paylaşılan veri çantası
-  GameEvent,       // Varsayılan event implementasyonu
-  Rule,            // Fluent kural builder
-  ActionSettings,  // Action parametreleri
-  FieldCondition,  // Alan karşılaştırma koşulu
+  AreEngine,      // Core engine
+  AreContext,      // Shared data bag
+  GameEvent,       // Default event implementation
+  Rule,            // Fluent rule builder
+  ActionSettings,  // Action parameters
+  FieldCondition,  // Field comparison condition
   MatchMode,       // All, Any, None, ExactlyOne
-  CompareOp,       // Equal, GreaterThan, Contains, In vb.
-} = require('are-core');
+  CompareOp,       // Equal, GreaterThan, Contains, In, etc.
+} = require('are-engine-core');
 ```
 
 ---
 
-## TypeScript Desteği
+## TypeScript Support
 
-Tip tanımları (`are-core.d.ts`) pakete dahildir. Ek kurulum gerekmez.
+Type definitions (`are-core.d.ts`) are included in the package. No additional setup required.
 
 ```typescript
-import { AreEngine, Rule, IAction, IEvent, AreContext, ActionSettings } from 'are-core';
+import { AreEngine, Rule, IAction, IEvent, AreContext, ActionSettings } from 'are-engine-core';
 
-// Kendi action tipini tanımla
+// Define a custom action type
 const myAction: IAction = {
   actionType: 'my_action',
-  execute: async (ctx: AreContext, settings: ActionSettings): Promise => {
-    const value = settings.get('key');
+  execute: async (ctx: AreContext, settings: ActionSettings): Promise<void> => {
+    const value = settings.get<string>('key');
     ctx.set('result', value);
   }
 };
@@ -320,34 +320,33 @@ const myAction: IAction = {
 
 ---
 
-## Farklı Ortamlarda Import
+## Import Patterns
 
 ```javascript
 // CommonJS (Node.js, Electron)
-const { AreEngine, Rule } = require('are-core');
+const { AreEngine, Rule } = require('are-engine-core');
 
 // ES Module (React, Vue, Angular, Vite, Next.js)
-import { AreEngine, Rule } from 'are-core';
+import { AreEngine, Rule } from 'are-engine-core';
 
 // Script tag (browser - global)
-// dist/are-core.js dosyasını doğrudan kullanabilirsin
-
+// You can use the dist/are-core.js file directly
 ```
 
 ---
 
-## Testler
+## Tests
 
 ```bash
 npm test
-# veya
+# or
 node test/test.js
 ```
 
-17 test: engine, koşullar, MatchMode, middleware, pipeline kontrolü, grup yönetimi, context paylaşımı.
+17 tests covering: engine, conditions, MatchMode, middleware, pipeline control, group management, and context sharing.
 
 ---
 
-## Lisans
+## License
 
-MIT
+MIT

package/dist/are-core.js

@@ -165,7 +165,7 @@ class AreEngine {
         this.onLog = null;
     }
 
-    // -- Kayıt --
+    // -- Registration --
 
     registerAction(actionTypeOrObj, handler) {
         if (typeof actionTypeOrObj === 'string') {
@@ -195,7 +195,7 @@ class AreEngine {
         return this;
     }
 
-    // -- Kural Yönetimi --
+    // -- Rule Management --
 
     enableRule(id) { var r = this._rules.find(function (r) { return r.ruleId === id; }); if (r) r.isEnabled = true; return this; }
     disableRule(id) { var r = this._rules.find(function (r) { return r.ruleId === id; }); if (r) r.isEnabled = false; return this; }
@@ -239,23 +239,23 @@ class AreEngine {
         var self = this;
 
         var coreProcess = async function () {
-            // 1) Doğrudan dinleyiciler
+            // 1) Direct listeners
             var listeners = self._listeners.get(evt.eventType) || [];
             for (var i = 0; i < listeners.length; i++) {
                 if (ctx.stopPipeline) break;
                 await listeners[i](evt, ctx);
             }
 
-            // 2) Eşleşen kurallar (önceliğe göre)
+            // 2) Matching rules (by priority)
             var matching = self._rules
                 .filter(function (r) { return r.isEnabled && r.eventTypes.indexOf(evt.eventType) !== -1; })
                 .sort(function (a, b) { return b.priority - a.priority; });
 
-            self._log('[ARE] Event \'' + evt.eventType + '\' → ' + matching.length + ' aday kural');
+            self._log('[ARE] Event \'' + evt.eventType + '\' → ' + matching.length + ' candidate rules');
 
             for (var j = 0; j < matching.length; j++) {
                 if (ctx.stopPipeline) {
-                    self._log('[ARE] Pipeline durduruldu');
+                    self._log('[ARE] Pipeline stopped');
                     break;
                 }
                 var rule = matching[j];
@@ -268,7 +268,7 @@ class AreEngine {
             }
         };
 
-        // Middleware zinciri
+        // Middleware chain
         var pipeline = coreProcess;
         for (var i = this._middlewares.length - 1; i >= 0; i--) {
             (function (mw, next) {
@@ -280,21 +280,21 @@ class AreEngine {
 
         result.pipelineStopped = ctx.stopPipeline;
         result.duration = Date.now() - start;
-        this._log('[ARE] Event \'' + evt.eventType + '\' tamamlandı: ' +
-            result.firedRules.length + ' tetiklendi, ' +
-            result.skippedRules.length + ' atlandı, ' +
+        this._log('[ARE] Event \'' + evt.eventType + '\' completed: ' +
+            result.firedRules.length + ' fired, ' +
+            result.skippedRules.length + ' skipped, ' +
             result.duration + 'ms');
         return result;
     }
 
-    // -- İç mekanizma --
+    // -- Internal --
 
     async _evaluateAndExecute(rule, evt, ctx) {
         var failedConditions = [];
         var conditionsMet = this._evaluateConditions(rule, evt, ctx, failedConditions);
 
         if (!conditionsMet) {
-            this._log('[ARE]   Kural \'' + rule.ruleId + '\' → koşullar sağlanmadı [' + failedConditions.join(', ') + ']');
+            this._log('[ARE]   Rule \'' + rule.ruleId + '\' → conditions not met [' + failedConditions.join(', ') + ']');
             return { ruleId: rule.ruleId, conditionsMet: false, executedActions: [], failedConditions: failedConditions };
         }
 
@@ -307,16 +307,16 @@ class AreEngine {
             var action = this._actions.get(binding.actionType);
 
             if (!action) {
-                this._log('[ARE]   ⚠ Action \'' + binding.actionType + '\' bulunamadı!');
+                this._log('[ARE]   Action \'' + binding.actionType + '\' not found!');
                 continue;
             }
 
             try {
-                this._log('[ARE]   → Action \'' + binding.actionType + '\' çalıştırılıyor');
+                this._log('[ARE]   → Executing action \'' + binding.actionType + '\'');
                 await action.execute(ctx, binding.settings);
                 executedActions.push(binding.actionType);
             } catch (err) {
-                this._log('[ARE]   ✗ Action \'' + binding.actionType + '\' hata: ' + err.message);
+                this._log('[ARE]   Action \'' + binding.actionType + '\' error: ' + err.message);
                 break;
             }
         }

package/dist/are-core.mjs

@@ -0,0 +1,358 @@
+// ============================================================================
+// ARE.Core - Action Rule Event Engine (ES Module)
+// Zero dependency - Browser, Node.js, React Native, Electron
+// ============================================================================
+
+// ── Enums ──
+
+const MatchMode = Object.freeze({
+    All: 'all',
+    Any: 'any',
+    None: 'none',
+    ExactlyOne: 'exactlyOne',
+});
+
+const CompareOp = Object.freeze({
+    Equal: 'eq',
+    NotEqual: 'neq',
+    GreaterThan: 'gt',
+    GreaterOrEqual: 'gte',
+    LessThan: 'lt',
+    LessOrEqual: 'lte',
+    Contains: 'contains',
+    StartsWith: 'startsWith',
+    In: 'in',
+});
+
+// ── AreContext ──
+
+class AreContext {
+    constructor() {
+        this._data = new Map();
+        this.currentEvent = null;
+        this.currentRule = null;
+        this.stopPipeline = false;
+        this.skipRemainingActions = false;
+    }
+    set(key, value) { this._data.set(key, value); }
+    get(key) { return this._data.get(key); }
+    has(key) { return this._data.has(key); }
+    remove(key) { this._data.delete(key); }
+    clear() { this._data.clear(); }
+}
+
+// ── ActionSettings ──
+
+class ActionSettings {
+    constructor() { this._values = {}; }
+    set(key, value) { this._values[key] = value; return this; }
+    get(key) { return this._values[key]; }
+    has(key) { return key in this._values; }
+    all() { return Object.assign({}, this._values); }
+}
+
+// ── GameEvent ──
+
+class GameEvent {
+    constructor(eventType) {
+        this.eventType = eventType;
+        this.data = {};
+        this.timestamp = new Date();
+    }
+    set(key, value) { this.data[key] = value; return this; }
+}
+
+// ── FieldCondition ──
+
+class FieldCondition {
+    constructor(fieldName, operator, expected) {
+        this.name = fieldName + ' ' + operator + ' ' + expected;
+        this.fieldName = fieldName;
+        this.operator = operator;
+        this.expected = expected;
+    }
+
+    evaluate(evt, _context) {
+        var actual = evt.data[this.fieldName];
+        if (actual === undefined) return false;
+
+        switch (this.operator) {
+            case CompareOp.Equal: return actual === this.expected;
+            case CompareOp.NotEqual: return actual !== this.expected;
+            case CompareOp.GreaterThan: return actual > this.expected;
+            case CompareOp.GreaterOrEqual: return actual >= this.expected;
+            case CompareOp.LessThan: return actual < this.expected;
+            case CompareOp.LessOrEqual: return actual <= this.expected;
+            case CompareOp.Contains: return String(actual).includes(String(this.expected));
+            case CompareOp.StartsWith: return String(actual).startsWith(String(this.expected));
+            case CompareOp.In: return Array.isArray(this.expected) && this.expected.includes(actual);
+            default: return false;
+        }
+    }
+}
+
+// ── Rule (Fluent Builder) ──
+
+class Rule {
+    constructor(ruleId) {
+        this.ruleId = ruleId;
+        this.group = null;
+        this.priority = 0;
+        this.isEnabled = true;
+        this.eventTypes = [];
+        this.conditions = [];
+        this.matchMode = MatchMode.All;
+        this.actions = [];
+    }
+
+    static create(ruleId) { return new Rule(ruleId); }
+
+    inGroup(group) { this.group = group; return this; }
+    withPriority(p) { this.priority = p; return this; }
+    enable() { this.isEnabled = true; return this; }
+    disable() { this.isEnabled = false; return this; }
+
+    on() {
+        for (var i = 0; i < arguments.length; i++) {
+            var et = arguments[i];
+            if (this.eventTypes.indexOf(et) === -1) this.eventTypes.push(et);
+        }
+        return this;
+    }
+
+    withMatchMode(mode) { this.matchMode = mode; return this; }
+
+    when(nameOrCondition, predicate) {
+        if (typeof nameOrCondition === 'object' && nameOrCondition.evaluate) {
+            this.conditions.push(nameOrCondition);
+        } else {
+            this.conditions.push({ name: nameOrCondition, evaluate: predicate });
+        }
+        return this;
+    }
+
+    whenField(field, op, expected) {
+        this.conditions.push(new FieldCondition(field, op, expected));
+        return this;
+    }
+
+    whenEquals(field, value) { return this.whenField(field, CompareOp.Equal, value); }
+    whenGreaterThan(field, value) { return this.whenField(field, CompareOp.GreaterThan, value); }
+    whenLessThan(field, value) { return this.whenField(field, CompareOp.LessThan, value); }
+
+    then(actionType, configure, order) {
+        var settings = new ActionSettings();
+        if (typeof configure === 'function') {
+            configure(settings);
+        } else if (typeof configure === 'number') {
+            order = configure;
+        }
+        this.actions.push({ actionType: actionType, settings: settings, order: order || 0 });
+        return this;
+    }
+}
+
+// ── AreEngine ──
+
+class AreEngine {
+    constructor() {
+        this._actions = new Map();
+        this._rules = [];
+        this._middlewares = [];
+        this._listeners = new Map();
+        this.onLog = null;
+    }
+
+    // -- Registration --
+
+    registerAction(actionTypeOrObj, handler) {
+        if (typeof actionTypeOrObj === 'string') {
+            this._actions.set(actionTypeOrObj, { actionType: actionTypeOrObj, execute: handler });
+        } else {
+            this._actions.set(actionTypeOrObj.actionType, actionTypeOrObj);
+        }
+        return this;
+    }
+
+    addRule(rule) { this._rules.push(rule); return this; }
+
+    addRules() {
+        for (var i = 0; i < arguments.length; i++) this._rules.push(arguments[i]);
+        return this;
+    }
+
+    use(order, handler) {
+        this._middlewares.push({ order: order, process: handler });
+        this._middlewares.sort(function (a, b) { return a.order - b.order; });
+        return this;
+    }
+
+    on(eventType, handler) {
+        if (!this._listeners.has(eventType)) this._listeners.set(eventType, []);
+        this._listeners.get(eventType).push(handler);
+        return this;
+    }
+
+    // -- Rule Management --
+
+    enableRule(id) { var r = this._rules.find(function (r) { return r.ruleId === id; }); if (r) r.isEnabled = true; return this; }
+    disableRule(id) { var r = this._rules.find(function (r) { return r.ruleId === id; }); if (r) r.isEnabled = false; return this; }
+    removeRule(id) { this._rules = this._rules.filter(function (r) { return r.ruleId !== id; }); return this; }
+
+    enableGroup(g) {
+        this._rules.forEach(function (r) { if (r.group === g) r.isEnabled = true; });
+        return this;
+    }
+
+    disableGroup(g) {
+        this._rules.forEach(function (r) { if (r.group === g) r.isEnabled = false; });
+        return this;
+    }
+
+    // -- Event Firing --
+
+    async fire(eventTypeOrEvent, configure, context) {
+        var evt;
+        if (typeof eventTypeOrEvent === 'string') {
+            evt = new GameEvent(eventTypeOrEvent);
+            if (typeof configure === 'function') configure(evt);
+        } else {
+            evt = eventTypeOrEvent;
+            if (configure instanceof AreContext) context = configure;
+        }
+
+        var start = Date.now();
+        var ctx = context || new AreContext();
+        ctx.currentEvent = evt;
+        ctx.stopPipeline = false;
+
+        var result = {
+            event: evt,
+            firedRules: [],
+            skippedRules: [],
+            pipelineStopped: false,
+            duration: 0
+        };
+
+        var self = this;
+
+        var coreProcess = async function () {
+            // 1) Direct listeners
+            var listeners = self._listeners.get(evt.eventType) || [];
+            for (var i = 0; i < listeners.length; i++) {
+                if (ctx.stopPipeline) break;
+                await listeners[i](evt, ctx);
+            }
+
+            // 2) Matching rules (by priority)
+            var matching = self._rules
+                .filter(function (r) { return r.isEnabled && r.eventTypes.indexOf(evt.eventType) !== -1; })
+                .sort(function (a, b) { return b.priority - a.priority; });
+
+            self._log('[ARE] Event \'' + evt.eventType + '\' → ' + matching.length + ' candidate rules');
+
+            for (var j = 0; j < matching.length; j++) {
+                if (ctx.stopPipeline) {
+                    self._log('[ARE] Pipeline stopped');
+                    break;
+                }
+                var rule = matching[j];
+                ctx.currentRule = rule;
+                ctx.skipRemainingActions = false;
+
+                var rr = await self._evaluateAndExecute(rule, evt, ctx);
+                if (rr.conditionsMet) result.firedRules.push(rr);
+                else result.skippedRules.push(rr);
+            }
+        };
+
+        // Middleware chain
+        var pipeline = coreProcess;
+        for (var i = this._middlewares.length - 1; i >= 0; i--) {
+            (function (mw, next) {
+                pipeline = function () { return mw.process(ctx, next); };
+            })(this._middlewares[i], pipeline);
+        }
+
+        await pipeline();
+
+        result.pipelineStopped = ctx.stopPipeline;
+        result.duration = Date.now() - start;
+        this._log('[ARE] Event \'' + evt.eventType + '\' completed: ' +
+            result.firedRules.length + ' fired, ' +
+            result.skippedRules.length + ' skipped, ' +
+            result.duration + 'ms');
+        return result;
+    }
+
+    // -- Internal --
+
+    async _evaluateAndExecute(rule, evt, ctx) {
+        var failedConditions = [];
+        var conditionsMet = this._evaluateConditions(rule, evt, ctx, failedConditions);
+
+        if (!conditionsMet) {
+            this._log('[ARE]   Rule \'' + rule.ruleId + '\' → conditions not met [' + failedConditions.join(', ') + ']');
+            return { ruleId: rule.ruleId, conditionsMet: false, executedActions: [], failedConditions: failedConditions };
+        }
+
+        var executedActions = [];
+        var ordered = rule.actions.slice().sort(function (a, b) { return a.order - b.order; });
+
+        for (var i = 0; i < ordered.length; i++) {
+            if (ctx.skipRemainingActions || ctx.stopPipeline) break;
+            var binding = ordered[i];
+            var action = this._actions.get(binding.actionType);
+
+            if (!action) {
+                this._log('[ARE]   Action \'' + binding.actionType + '\' not found!');
+                continue;
+            }
+
+            try {
+                this._log('[ARE]   → Executing action \'' + binding.actionType + '\'');
+                await action.execute(ctx, binding.settings);
+                executedActions.push(binding.actionType);
+            } catch (err) {
+                this._log('[ARE]   Action \'' + binding.actionType + '\' error: ' + err.message);
+                break;
+            }
+        }
+
+        return { ruleId: rule.ruleId, conditionsMet: true, executedActions: executedActions, failedConditions: [] };
+    }
+
+    _evaluateConditions(rule, evt, ctx, failed) {
+        if (rule.conditions.length === 0) return true;
+
+        var results = [];
+        for (var i = 0; i < rule.conditions.length; i++) {
+            var c = rule.conditions[i];
+            var r = c.evaluate(evt, ctx);
+            if (!r) failed.push(c.name);
+            results.push(r);
+        }
+
+        switch (rule.matchMode) {
+            case MatchMode.All: return results.every(function (r) { return r; });
+            case MatchMode.Any: return results.some(function (r) { return r; });
+            case MatchMode.None: return results.every(function (r) { return !r; });
+            case MatchMode.ExactlyOne: return results.filter(function (r) { return r; }).length === 1;
+            default: return false;
+        }
+    }
+
+    _log(msg) { if (this.onLog) this.onLog(msg); }
+}
+
+// ── Export (ESM) ──
+export {
+    AreEngine,
+    AreContext,
+    GameEvent,
+    Rule,
+    ActionSettings,
+    FieldCondition,
+    MatchMode,
+    CompareOp
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "are-engine-core",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Action Rule Event Engine - Zero dependency, cross-platform, lightweight event-rule-action engine",
   "main": "dist/are-core.js",
   "types": "dist/are-core.d.ts",