are-engine-core 1.0.0

package/README.md

@@ -0,0 +1,353 @@
+# are-core — Action Rule Event Engine
+
+Sıfır bağımlılık, hafif olay-kural-eylem motoru.
+
+Browser, Node.js, React, Vue, React Native, Electron — her JS/TS ortamında çalışır.
+
+> Bu paket, C# [ARE.Core](../ARE.Core/) motorunun JavaScript/TypeScript portudur.
+> Aynı mimari, aynı API, aynı davranış.
+
+---
+
+## Kurulum
+
+```bash
+npm install are-core
+```
+
+Build adımı yok. TypeScript tip tanımları dahil gelir.
+
+---
+
+## Hızlı Başlangıç
+
+```javascript
+const { AreEngine, Rule } = require('are-core');
+// veya
+// import { AreEngine, Rule } from 'are-core';
+
+// 1) Engine oluştur
+const engine = new AreEngine();
+
+// 2) Action kaydet
+engine.registerAction('send_email', async (ctx, s) => {
+  console.log('Email gönderildi:', s.get('template'));
+});
+
+// 3) Kural tanımla
+engine.addRule(
+  Rule.create('vip_order')
+    .on('order.created')
+    .whenGreaterThan('total', 5000)
+    .then('send_email', s => s.set('template', 'vip_welcome'))
+);
+
+// 4) Event fırlat
+await engine.fire('order.created', e => e.set('total', 7500));
+// Çıktı: Email gönderildi: vip_welcome
+```
+
+---
+
+## Detaylı Kullanım
+
+### Action Tanımlama — Obje ile
+
+```javascript
+const damageAction = {
+  actionType: 'damage',
+  execute: async (ctx, settings) => {
+    const amount = settings.get('amount');
+    console.log(`${amount} hasar verildi!`);
+    ctx.set('lastDamage', amount);
+  }
+};
+
+engine.registerAction(damageAction);
+```
+
+### Action Tanımlama — Inline
+
+```javascript
+engine.registerAction('log', async (ctx, s) => {
+  console.log(s.get('message'));
+});
+```
+
+### Kural Tanımlama — Fluent Builder
+
+```javascript
+engine.addRule(
+  Rule.create('boss_room')
+    .inGroup('spawning')
+    .withPriority(10)
+    .on('player.enter_zone')
+    .withMatchMode(MatchMode.All)
+    .whenEquals('zone_type', 'boss')
+    .when('level_check', (evt) => (evt.data.player_level ?? 0) >= 5)
+    .then('spawn_enemy', s => s.set('type', 'dragon').set('count', 1))
+    .then('play_sound', s => s.set('clip', 'boss_roar'))
+);
+```
+
+### Birden Fazla Event Dinleme
+
+```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ı!'))
+```
+
+### Koşul Tipleri
+
+```javascript
+// Alan karşılaştırma (deklaratif)
+.whenEquals('status', 'active')
+.whenGreaterThan('score', 100)
+.whenLessThan('stock', 10)
+.whenField('category', CompareOp.Contains, 'premium')
+.whenField('role', CompareOp.In, ['admin', 'moderator'])
+
+// Lambda (esnek)
+.when('custom_check', (evt, ctx) => {
+  return evt.data.total > 1000 && ctx.get('user_type') === 'vip';
+})
+```
+
+### MatchMode — Koşul Eşleşme Modları
+
+```javascript
+const { MatchMode } = require('are-core');
+
+// Tüm koşullar doğru olmalı (AND) — varsayılan
+.withMatchMode(MatchMode.All)
+
+// En az bir koşul doğru olmalı (OR)
+.withMatchMode(MatchMode.Any)
+
+// Hiçbir koşul doğru olmamalı (NOT)
+.withMatchMode(MatchMode.None)
+
+// Tam olarak bir koşul doğru olmalı
+.withMatchMode(MatchMode.ExactlyOne)
+```
+
+### Middleware
+
+```javascript
+// Loglama
+engine.use(0, async (ctx, next) => {
+  console.log('Event başladı:', ctx.currentEvent.eventType);
+  const start = Date.now();
+  await next();
+  console.log('Event bitti:', (Date.now() - start) + 'ms');
+});
+
+// Auth kontrolü
+engine.use(-10, async (ctx, next) => {
+  if (!ctx.get('isAuthenticated')) {
+    ctx.stopPipeline = true;
+    return;
+  }
+  await next();
+});
+```
+
+### Doğrudan Listener (Kural Olmadan)
+
+```javascript
+engine.on('order.created', async (evt, ctx) => {
+  console.log('Sipariş:', evt.data.order_id);
+});
+```
+
+### Dinamik Kural Yönetimi
+
+```javascript
+// Tek kural
+engine.disableRule('seasonal_discount');
+engine.enableRule('seasonal_discount');
+engine.removeRule('old_rule');
+
+// Grup toplu
+engine.disableGroup('marketing');
+engine.enableGroup('marketing');
+
+// Runtime'da yeni kural ekle
+engine.addRule(
+  Rule.create('flash_sale')
+    .inGroup('marketing')
+    .on('order.created')
+    .whenGreaterThan('total', 100)
+    .then('apply_discount', s => s.set('percent', 20))
+);
+```
+
+### Akış Kontrolü
+
+```javascript
+// Pipeline'ı tamamen durdur (sonraki kurallar çalışmaz)
+engine.registerAction('validate', async (ctx) => {
+  if (!ctx.currentEvent.data.valid) {
+    ctx.stopPipeline = true;
+  }
+});
+
+// Sadece mevcut kuralın kalan action'larını atla
+engine.registerAction('conditional_skip', async (ctx) => {
+  if (someCondition) {
+    ctx.skipRemainingActions = true;
+  }
+});
+```
+
+### Context — Action'lar Arası Veri Paylaşımı
+
+```javascript
+engine.registerAction('calculate', async (ctx) => {
+  ctx.set('total', 1500);
+});
+
+engine.registerAction('apply_tax', async (ctx) => {
+  const total = ctx.get('total');
+  ctx.set('totalWithTax', total * 1.18);
+});
+
+// İkisi aynı event'te sırayla çalışırsa, context üzerinden veri paylaşır
+```
+
+### Sonuç Okuma
+
+```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');
+
+result.firedRules.forEach(r => {
+  console.log(`  ${r.ruleId} → ${r.executedActions.join(', ')}`);
+});
+
+result.skippedRules.forEach(r => {
+  console.log(`  ${r.ruleId} → sağlanmayan: ${r.failedConditions.join(', ')}`);
+});
+```
+
+---
+
+## React Kullanımı
+
+```jsx
+import { AreEngine, Rule, GameEvent, AreContext } from 'are-core';
+import { useRef, useState } from 'react';
+
+function useAreEngine(setup) {
+  const engineRef = useRef(null);
+  if (!engineRef.current) {
+    engineRef.current = new AreEngine();
+    setup(engineRef.current);
+  }
+
+  const fire = async (eventType, data) => {
+    const ctx = new AreContext();
+    const evt = new GameEvent(eventType);
+    Object.entries(data).forEach(([k, v]) => evt.set(k, v));
+    return await engineRef.current.fire(evt, ctx);
+  };
+
+  return { fire, engine: engineRef.current };
+}
+
+// Kullanım
+function App() {
+  const { fire } = useAreEngine((engine) => {
+    engine.registerAction('toast', async (ctx, s) => {
+      ctx.set('toast', s.get('message'));
+    });
+
+    engine.addRule(
+      Rule.create('big_order')
+        .on('cart.checkout')
+        .whenGreaterThan('total', 500)
+        .then('toast', s => s.set('message', '🎉 Kargo bedava!'))
+    );
+  });
+
+  return <button onClick={() => fire('cart.checkout', { total: 700 })}>Ödeme;
+}
+```
+
+---
+
+## Export Listesi
+
+```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
+  MatchMode,       // All, Any, None, ExactlyOne
+  CompareOp,       // Equal, GreaterThan, Contains, In vb.
+} = require('are-core');
+```
+
+---
+
+## TypeScript Desteği
+
+Tip tanımları (`are-core.d.ts`) pakete dahildir. Ek kurulum gerekmez.
+
+```typescript
+import { AreEngine, Rule, IAction, IEvent, AreContext, ActionSettings } from 'are-core';
+
+// Kendi action tipini tanımla
+const myAction: IAction = {
+  actionType: 'my_action',
+  execute: async (ctx: AreContext, settings: ActionSettings): Promise => {
+    const value = settings.get('key');
+    ctx.set('result', value);
+  }
+};
+```
+
+---
+
+## Farklı Ortamlarda Import
+
+```javascript
+// CommonJS (Node.js, Electron)
+const { AreEngine, Rule } = require('are-core');
+
+// ES Module (React, Vue, Angular, Vite, Next.js)
+import { AreEngine, Rule } from 'are-core';
+
+// Script tag (browser - global)
+// dist/are-core.js dosyasını doğrudan kullanabilirsin
+
+```
+
+---
+
+## Testler
+
+```bash
+npm test
+# veya
+node test/test.js
+```
+
+17 test: engine, koşullar, MatchMode, middleware, pipeline kontrolü, grup yönetimi, context paylaşımı.
+
+---
+
+## Lisans
+
+MIT

package/dist/are-core.d.ts

@@ -0,0 +1,147 @@
+// ARE.Core Type Definitions
+
+export declare enum MatchMode {
+    All = 'all',
+    Any = 'any',
+    None = 'none',
+    ExactlyOne = 'exactlyOne',
+}
+
+export declare enum CompareOp {
+    Equal = 'eq',
+    NotEqual = 'neq',
+    GreaterThan = 'gt',
+    GreaterOrEqual = 'gte',
+    LessThan = 'lt',
+    LessOrEqual = 'lte',
+    Contains = 'contains',
+    StartsWith = 'startsWith',
+    In = 'in',
+}
+
+export interface IEvent {
+    eventType: string;
+    data: Record<string, any>;
+    timestamp: Date;
+}
+
+export interface IAction {
+    actionType: string;
+    execute(context: AreContext, settings: ActionSettings): Promise<void>;
+}
+
+export interface ICondition {
+    name: string;
+    evaluate(evt: IEvent, context: AreContext): boolean;
+}
+
+export interface IMiddleware {
+    order: number;
+    process(context: AreContext, next: () => Promise<void>): Promise<void>;
+}
+
+export interface ActionBinding {
+    actionType: string;
+    settings: ActionSettings;
+    order: number;
+}
+
+export interface EngineResult {
+    event: IEvent;
+    firedRules: RuleResult[];
+    skippedRules: RuleResult[];
+    pipelineStopped: boolean;
+    duration: number;
+}
+
+export interface RuleResult {
+    ruleId: string;
+    conditionsMet: boolean;
+    executedActions: string[];
+    failedConditions: string[];
+}
+
+// ── Classes ──
+
+export declare class AreContext {
+    currentEvent: IEvent | null;
+    currentRule: Rule | null;
+    stopPipeline: boolean;
+    skipRemainingActions: boolean;
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T | undefined;
+    has(key: string): boolean;
+    remove(key: string): void;
+    clear(): void;
+}
+
+export declare class ActionSettings {
+    set(key: string, value: any): this;
+    get<T>(key: string): T | undefined;
+    has(key: string): boolean;
+    all(): Record<string, any>;
+}
+
+export declare class GameEvent implements IEvent {
+    readonly eventType: string;
+    readonly data: Record<string, any>;
+    readonly timestamp: Date;
+    constructor(eventType: string);
+    set(key: string, value: any): this;
+}
+
+export declare class FieldCondition implements ICondition {
+    readonly name: string;
+    readonly fieldName: string;
+    readonly operator: CompareOp;
+    readonly expected: any;
+    constructor(fieldName: string, op: CompareOp, expected: any);
+    evaluate(evt: IEvent, context: AreContext): boolean;
+}
+
+export declare class Rule {
+    ruleId: string;
+    group: string | null;
+    priority: number;
+    isEnabled: boolean;
+    eventTypes: string[];
+    conditions: ICondition[];
+    matchMode: MatchMode;
+    actions: ActionBinding[];
+
+    static create(ruleId: string): Rule;
+    inGroup(group: string): this;
+    withPriority(priority: number): this;
+    enable(): this;
+    disable(): this;
+    on(...eventTypes: string[]): this;
+    withMatchMode(mode: MatchMode): this;
+    when(name: string, predicate: (evt: IEvent, ctx: AreContext) => boolean): this;
+    when(condition: ICondition): this;
+    whenField(field: string, op: CompareOp, expected: any): this;
+    whenEquals(field: string, value: any): this;
+    whenGreaterThan(field: string, value: any): this;
+    whenLessThan(field: string, value: any): this;
+    then(actionType: string, order?: number): this;
+    then(actionType: string, configure: (s: ActionSettings) => void, order?: number): this;
+}
+
+export declare class AreEngine {
+    onLog: ((msg: string) => void) | null;
+
+    registerAction(action: IAction): this;
+    registerAction(actionType: string, handler: (ctx: AreContext, s: ActionSettings) => Promise<void>): this;
+    addRule(rule: Rule): this;
+    addRules(...rules: Rule[]): this;
+    use(order: number, handler: (ctx: AreContext, next: () => Promise<void>) => Promise<void>): this;
+    on(eventType: string, handler: (evt: IEvent, ctx: AreContext) => Promise<void>): this;
+
+    enableRule(id: string): this;
+    disableRule(id: string): this;
+    removeRule(id: string): this;
+    enableGroup(group: string): this;
+    disableGroup(group: string): this;
+
+    fire(evt: IEvent, context?: AreContext): Promise<EngineResult>;
+    fire(eventType: string, configure?: (e: GameEvent) => void, context?: AreContext): Promise<EngineResult>;
+}

package/dist/are-core.js

@@ -0,0 +1,360 @@
+'use strict';
+
+// ============================================================================
+// ARE.Core - Action Rule Event Engine
+// 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;
+    }
+
+    // -- Kayıt --
+
+    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;
+    }
+
+    // -- Kural Yönetimi --
+
+    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) Doğrudan dinleyiciler
+            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)
+            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');
+
+            for (var j = 0; j < matching.length; j++) {
+                if (ctx.stopPipeline) {
+                    self._log('[ARE] Pipeline durduruldu');
+                    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 zinciri
+        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 + '\' tamamlandı: ' +
+            result.firedRules.length + ' tetiklendi, ' +
+            result.skippedRules.length + ' atlandı, ' +
+            result.duration + 'ms');
+        return result;
+    }
+
+    // -- İç mekanizma --
+
+    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(', ') + ']');
+            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 + '\' bulunamadı!');
+                continue;
+            }
+
+            try {
+                this._log('[ARE]   → Action \'' + binding.actionType + '\' çalıştırılıyor');
+                await action.execute(ctx, binding.settings);
+                executedActions.push(binding.actionType);
+            } catch (err) {
+                this._log('[ARE]   ✗ Action \'' + binding.actionType + '\' hata: ' + 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 ──
+module.exports = {
+    AreEngine: AreEngine,
+    AreContext: AreContext,
+    GameEvent: GameEvent,
+    Rule: Rule,
+    ActionSettings: ActionSettings,
+    FieldCondition: FieldCondition,
+    MatchMode: MatchMode,
+    CompareOp: CompareOp
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "are-engine-core",
+  "version": "1.0.0",
+  "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",
+  "author": "BeratARPA",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BeratARPA/ARE"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/are-core.js",
+      "import": "./dist/are-core.mjs",
+      "types": "./dist/are-core.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "rules-engine",
+    "event-driven",
+    "action",
+    "cross-platform",
+    "game-engine",
+    "lightweight",
+    "zero-dependency"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist/",
+    "README.md"
+  ]
+}