@plures/praxis 1.0.3 → 1.1.1

package/src/__tests__/dsl.test.ts

@@ -2,7 +2,7 @@
  * DSL tests
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   defineFact,
   defineEvent,
@@ -11,141 +11,135 @@ import {
   defineModule,
   findEvent,
   findFact,
-} from "../dsl/index.js";
+} from '../dsl/index.js';
 
-describe("DSL Helpers", () => {
-  describe("defineFact", () => {
-    it("should create a fact definition", () => {
-      const TestFact = defineFact<"TestFact", { value: number }>("TestFact");
+describe('DSL Helpers', () => {
+  describe('defineFact', () => {
+    it('should create a fact definition', () => {
+      const TestFact = defineFact<'TestFact', { value: number }>('TestFact');
 
-      expect(TestFact.tag).toBe("TestFact");
+      expect(TestFact.tag).toBe('TestFact');
 
       const fact = TestFact.create({ value: 42 });
-      expect(fact.tag).toBe("TestFact");
+      expect(fact.tag).toBe('TestFact');
       expect(fact.payload.value).toBe(42);
     });
 
-    it("should provide type guard", () => {
-      const TestFact = defineFact<"TestFact", { value: number }>("TestFact");
+    it('should provide type guard', () => {
+      const TestFact = defineFact<'TestFact', { value: number }>('TestFact');
       const fact = TestFact.create({ value: 42 });
 
       expect(TestFact.is(fact)).toBe(true);
-      expect(TestFact.is({ tag: "OtherFact", payload: {} })).toBe(false);
+      expect(TestFact.is({ tag: 'OtherFact', payload: {} })).toBe(false);
     });
   });
 
-  describe("defineEvent", () => {
-    it("should create an event definition", () => {
-      const TestEvent = defineEvent<"TEST", { action: string }>("TEST");
+  describe('defineEvent', () => {
+    it('should create an event definition', () => {
+      const TestEvent = defineEvent<'TEST', { action: string }>('TEST');
 
-      expect(TestEvent.tag).toBe("TEST");
+      expect(TestEvent.tag).toBe('TEST');
 
-      const event = TestEvent.create({ action: "test" });
-      expect(event.tag).toBe("TEST");
-      expect(event.payload.action).toBe("test");
+      const event = TestEvent.create({ action: 'test' });
+      expect(event.tag).toBe('TEST');
+      expect(event.payload.action).toBe('test');
     });
 
-    it("should provide type guard", () => {
-      const TestEvent = defineEvent<"TEST", { action: string }>("TEST");
-      const event = TestEvent.create({ action: "test" });
+    it('should provide type guard', () => {
+      const TestEvent = defineEvent<'TEST', { action: string }>('TEST');
+      const event = TestEvent.create({ action: 'test' });
 
       expect(TestEvent.is(event)).toBe(true);
-      expect(TestEvent.is({ tag: "OTHER", payload: {} })).toBe(false);
+      expect(TestEvent.is({ tag: 'OTHER', payload: {} })).toBe(false);
     });
   });
 
-  describe("defineRule", () => {
-    it("should create a rule descriptor", () => {
+  describe('defineRule', () => {
+    it('should create a rule descriptor', () => {
       const rule = defineRule({
-        id: "test.rule",
-        description: "Test rule",
+        id: 'test.rule',
+        description: 'Test rule',
         impl: () => [],
       });
 
-      expect(rule.id).toBe("test.rule");
-      expect(rule.description).toBe("Test rule");
-      expect(typeof rule.impl).toBe("function");
+      expect(rule.id).toBe('test.rule');
+      expect(rule.description).toBe('Test rule');
+      expect(typeof rule.impl).toBe('function');
     });
   });
 
-  describe("defineConstraint", () => {
-    it("should create a constraint descriptor", () => {
+  describe('defineConstraint', () => {
+    it('should create a constraint descriptor', () => {
       const constraint = defineConstraint({
-        id: "test.constraint",
-        description: "Test constraint",
+        id: 'test.constraint',
+        description: 'Test constraint',
         impl: () => true,
       });
 
-      expect(constraint.id).toBe("test.constraint");
-      expect(constraint.description).toBe("Test constraint");
-      expect(typeof constraint.impl).toBe("function");
+      expect(constraint.id).toBe('test.constraint');
+      expect(constraint.description).toBe('Test constraint');
+      expect(typeof constraint.impl).toBe('function');
     });
   });
 
-  describe("defineModule", () => {
-    it("should create a module", () => {
+  describe('defineModule', () => {
+    it('should create a module', () => {
       const rule = defineRule({
-        id: "test.rule",
-        description: "Test rule",
+        id: 'test.rule',
+        description: 'Test rule',
         impl: () => [],
       });
 
       const constraint = defineConstraint({
-        id: "test.constraint",
-        description: "Test constraint",
+        id: 'test.constraint',
+        description: 'Test constraint',
         impl: () => true,
       });
 
       const module = defineModule({
         rules: [rule],
         constraints: [constraint],
-        meta: { version: "1.0.0" },
+        meta: { version: '1.0.0' },
       });
 
       expect(module.rules).toHaveLength(1);
       expect(module.constraints).toHaveLength(1);
-      expect(module.meta?.version).toBe("1.0.0");
+      expect(module.meta?.version).toBe('1.0.0');
     });
   });
 
-  describe("findEvent", () => {
-    it("should find matching event", () => {
-      const TestEvent = defineEvent<"TEST", { value: number }>("TEST");
-      const events = [
-        { tag: "OTHER", payload: {} },
-        TestEvent.create({ value: 42 }),
-      ];
+  describe('findEvent', () => {
+    it('should find matching event', () => {
+      const TestEvent = defineEvent<'TEST', { value: number }>('TEST');
+      const events = [{ tag: 'OTHER', payload: {} }, TestEvent.create({ value: 42 })];
 
       const found = findEvent(events, TestEvent);
       expect(found).toBeDefined();
       expect(found?.payload.value).toBe(42);
     });
 
-    it("should return undefined if not found", () => {
-      const TestEvent = defineEvent<"TEST", { value: number }>("TEST");
-      const events = [{ tag: "OTHER", payload: {} }];
+    it('should return undefined if not found', () => {
+      const TestEvent = defineEvent<'TEST', { value: number }>('TEST');
+      const events = [{ tag: 'OTHER', payload: {} }];
 
       const found = findEvent(events, TestEvent);
       expect(found).toBeUndefined();
     });
   });
 
-  describe("findFact", () => {
-    it("should find matching fact", () => {
-      const TestFact = defineFact<"TestFact", { value: number }>("TestFact");
-      const facts = [
-        { tag: "OtherFact", payload: {} },
-        TestFact.create({ value: 42 }),
-      ];
+  describe('findFact', () => {
+    it('should find matching fact', () => {
+      const TestFact = defineFact<'TestFact', { value: number }>('TestFact');
+      const facts = [{ tag: 'OtherFact', payload: {} }, TestFact.create({ value: 42 })];
 
       const found = findFact(facts, TestFact);
       expect(found).toBeDefined();
       expect(found?.payload.value).toBe(42);
     });
 
-    it("should return undefined if not found", () => {
-      const TestFact = defineFact<"TestFact", { value: number }>("TestFact");
-      const facts = [{ tag: "OtherFact", payload: {} }];
+    it('should return undefined if not found', () => {
+      const TestFact = defineFact<'TestFact', { value: number }>('TestFact');
+      const facts = [{ tag: 'OtherFact', payload: {} }];
 
       const found = findFact(facts, TestFact);
       expect(found).toBeUndefined();

package/src/__tests__/edge-cases.test.ts

@@ -2,27 +2,27 @@
  * Edge cases and failure path tests
  */
 
-import { describe, it, expect } from "vitest";
-import { createPraxisEngine } from "../core/engine.js";
-import { PraxisRegistry } from "../core/rules.js";
+import { describe, it, expect } from 'vitest';
+import { createPraxisEngine } from '../core/engine.js';
+import { PraxisRegistry } from '../core/rules.js';
 import {
   defineRule,
   defineConstraint,
   defineEvent,
   defineFact,
   defineModule,
-} from "../dsl/index.js";
+} from '../dsl/index.js';
 
-describe("Edge Cases and Failure Paths", () => {
-  describe("Rule Errors", () => {
-    it("should handle rule that throws an error", () => {
-      const ErrorEvent = defineEvent<"ERROR", {}>("ERROR");
+describe('Edge Cases and Failure Paths', () => {
+  describe('Rule Errors', () => {
+    it('should handle rule that throws an error', () => {
+      const ErrorEvent = defineEvent<'ERROR', {}>('ERROR');
 
       const errorRule = defineRule<{ value: number }>({
-        id: "error.rule",
-        description: "Rule that throws",
+        id: 'error.rule',
+        description: 'Rule that throws',
         impl: () => {
-          throw new Error("Intentional error");
+          throw new Error('Intentional error');
         },
       });
 
@@ -37,29 +37,29 @@ describe("Edge Cases and Failure Paths", () => {
       const result = engine.step([ErrorEvent.create({})]);
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("rule-error");
-      expect(result.diagnostics[0]?.message).toContain("Intentional error");
+      expect(result.diagnostics[0]?.kind).toBe('rule-error');
+      expect(result.diagnostics[0]?.message).toContain('Intentional error');
     });
 
-    it("should continue processing other rules after one fails", () => {
-      const TestEvent = defineEvent<"TEST", {}>("TEST");
-      const Success = defineFact<"Success", { ruleId: string }>("Success");
+    it('should continue processing other rules after one fails', () => {
+      const TestEvent = defineEvent<'TEST', {}>('TEST');
+      const Success = defineFact<'Success', { ruleId: string }>('Success');
 
       const errorRule = defineRule<{ count: number }>({
-        id: "error.rule",
-        description: "Rule that throws",
+        id: 'error.rule',
+        description: 'Rule that throws',
         impl: () => {
-          throw new Error("Error");
+          throw new Error('Error');
         },
       });
 
       const successRule = defineRule<{ count: number }>({
-        id: "success.rule",
-        description: "Rule that succeeds",
+        id: 'success.rule',
+        description: 'Rule that succeeds',
         impl: (state, events) => {
           if (events.some(TestEvent.is)) {
             state.context.count += 1;
-            return [Success.create({ ruleId: "success.rule" })];
+            return [Success.create({ ruleId: 'success.rule' })];
           }
           return [];
         },
@@ -78,20 +78,20 @@ describe("Edge Cases and Failure Paths", () => {
 
       // Should have both error diagnostic and success fact
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("rule-error");
-      expect(result.state.facts.some((f) => f.tag === "Success")).toBe(true);
+      expect(result.diagnostics[0]?.kind).toBe('rule-error');
+      expect(result.state.facts.some((f) => f.tag === 'Success')).toBe(true);
       expect(engine.getContext().count).toBe(1);
     });
 
-    it("should handle rule returning invalid data", () => {
-      const TestEvent = defineEvent<"TEST", {}>("TEST");
+    it('should handle rule returning invalid data', () => {
+      const TestEvent = defineEvent<'TEST', {}>('TEST');
 
       const invalidRule = defineRule<{ value: number }>({
-        id: "invalid.rule",
-        description: "Rule that returns invalid facts",
+        id: 'invalid.rule',
+        description: 'Rule that returns invalid facts',
         impl: () => {
           // Return invalid fact structure
-          return [{ tag: "Invalid", notPayload: "wrong" }] as any;
+          return [{ tag: 'Invalid', notPayload: 'wrong' }] as any;
         },
       });
 
@@ -109,13 +109,13 @@ describe("Edge Cases and Failure Paths", () => {
     });
   });
 
-  describe("Constraint Violations", () => {
-    it("should handle constraint that throws an error", () => {
+  describe('Constraint Violations', () => {
+    it('should handle constraint that throws an error', () => {
       const errorConstraint = defineConstraint<{ value: number }>({
-        id: "error.constraint",
-        description: "Constraint that throws",
+        id: 'error.constraint',
+        description: 'Constraint that throws',
         impl: () => {
-          throw new Error("Constraint error");
+          throw new Error('Constraint error');
         },
       });
 
@@ -130,14 +130,14 @@ describe("Edge Cases and Failure Paths", () => {
       const result = engine.step([]);
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("constraint-violation");
-      expect(result.diagnostics[0]?.message).toContain("Constraint error");
+      expect(result.diagnostics[0]?.kind).toBe('constraint-violation');
+      expect(result.diagnostics[0]?.message).toContain('Constraint error');
     });
 
-    it("should report constraint violation with false return", () => {
+    it('should report constraint violation with false return', () => {
       const failConstraint = defineConstraint<{ value: number }>({
-        id: "fail.constraint",
-        description: "Always fails",
+        id: 'fail.constraint',
+        description: 'Always fails',
         impl: () => false,
       });
 
@@ -152,16 +152,16 @@ describe("Edge Cases and Failure Paths", () => {
       const result = engine.step([]);
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("constraint-violation");
-      expect(result.diagnostics[0]?.message).toContain("fail.constraint");
+      expect(result.diagnostics[0]?.kind).toBe('constraint-violation');
+      expect(result.diagnostics[0]?.message).toContain('fail.constraint');
     });
 
-    it("should report constraint violation with custom message", () => {
+    it('should report constraint violation with custom message', () => {
       const customMessageConstraint = defineConstraint<{ value: number }>({
-        id: "custom.constraint",
-        description: "Custom message constraint",
+        id: 'custom.constraint',
+        description: 'Custom message constraint',
         impl: (state) => {
-          return state.context.value >= 0 || "Value must be non-negative";
+          return state.context.value >= 0 || 'Value must be non-negative';
         },
       });
 
@@ -176,20 +176,20 @@ describe("Edge Cases and Failure Paths", () => {
       const result = engine.step([]);
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.message).toBe("Value must be non-negative");
+      expect(result.diagnostics[0]?.message).toBe('Value must be non-negative');
     });
 
-    it("should check multiple constraints and report all violations", () => {
+    it('should check multiple constraints and report all violations', () => {
       const constraint1 = defineConstraint<{ value: number }>({
-        id: "constraint1",
-        description: "Constraint 1",
-        impl: () => "Violation 1",
+        id: 'constraint1',
+        description: 'Constraint 1',
+        impl: () => 'Violation 1',
       });
 
       const constraint2 = defineConstraint<{ value: number }>({
-        id: "constraint2",
-        description: "Constraint 2",
-        impl: () => "Violation 2",
+        id: 'constraint2',
+        description: 'Constraint 2',
+        impl: () => 'Violation 2',
       });
 
       const registry = new PraxisRegistry<{ value: number }>();
@@ -204,13 +204,13 @@ describe("Edge Cases and Failure Paths", () => {
       const result = engine.step([]);
 
       expect(result.diagnostics).toHaveLength(2);
-      expect(result.diagnostics[0]?.message).toBe("Violation 1");
-      expect(result.diagnostics[1]?.message).toBe("Violation 2");
+      expect(result.diagnostics[0]?.message).toBe('Violation 1');
+      expect(result.diagnostics[1]?.message).toBe('Violation 2');
     });
   });
 
-  describe("Registry Edge Cases", () => {
-    it("should handle non-existent rule ID in config", () => {
+  describe('Registry Edge Cases', () => {
+    it('should handle non-existent rule ID in config', () => {
       const registry = new PraxisRegistry<{ value: number }>();
       const engine = createPraxisEngine({
         initialContext: { value: 0 },
@@ -218,16 +218,16 @@ describe("Edge Cases and Failure Paths", () => {
       });
 
       const result = engine.stepWithConfig([], {
-        ruleIds: ["nonexistent.rule"],
+        ruleIds: ['nonexistent.rule'],
         constraintIds: [],
       });
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("rule-error");
-      expect(result.diagnostics[0]?.message).toContain("not found in registry");
+      expect(result.diagnostics[0]?.kind).toBe('rule-error');
+      expect(result.diagnostics[0]?.message).toContain('not found in registry');
     });
 
-    it("should handle non-existent constraint ID in config", () => {
+    it('should handle non-existent constraint ID in config', () => {
       const registry = new PraxisRegistry<{ value: number }>();
       const engine = createPraxisEngine({
         initialContext: { value: 0 },
@@ -236,18 +236,18 @@ describe("Edge Cases and Failure Paths", () => {
 
       const result = engine.stepWithConfig([], {
         ruleIds: [],
-        constraintIds: ["nonexistent.constraint"],
+        constraintIds: ['nonexistent.constraint'],
       });
 
       expect(result.diagnostics).toHaveLength(1);
-      expect(result.diagnostics[0]?.kind).toBe("constraint-violation");
-      expect(result.diagnostics[0]?.message).toContain("not found in registry");
+      expect(result.diagnostics[0]?.kind).toBe('constraint-violation');
+      expect(result.diagnostics[0]?.message).toContain('not found in registry');
     });
 
-    it("should throw when registering duplicate rule IDs", () => {
+    it('should throw when registering duplicate rule IDs', () => {
       const rule = defineRule({
-        id: "duplicate",
-        description: "Test",
+        id: 'duplicate',
+        description: 'Test',
         impl: () => [],
       });
 
@@ -259,10 +259,10 @@ describe("Edge Cases and Failure Paths", () => {
       );
     });
 
-    it("should throw when registering duplicate constraint IDs", () => {
+    it('should throw when registering duplicate constraint IDs', () => {
       const constraint = defineConstraint({
-        id: "duplicate",
-        description: "Test",
+        id: 'duplicate',
+        description: 'Test',
         impl: () => true,
       });
 
@@ -274,17 +274,17 @@ describe("Edge Cases and Failure Paths", () => {
       );
     });
 
-    it("should register module with multiple rules and constraints", () => {
+    it('should register module with multiple rules and constraints', () => {
       const module = defineModule({
         rules: [
-          defineRule({ id: "rule1", description: "Rule 1", impl: () => [] }),
-          defineRule({ id: "rule2", description: "Rule 2", impl: () => [] }),
+          defineRule({ id: 'rule1', description: 'Rule 1', impl: () => [] }),
+          defineRule({ id: 'rule2', description: 'Rule 2', impl: () => [] }),
         ],
         constraints: [
-          defineConstraint({ id: "c1", description: "C1", impl: () => true }),
-          defineConstraint({ id: "c2", description: "C2", impl: () => true }),
+          defineConstraint({ id: 'c1', description: 'C1', impl: () => true }),
+          defineConstraint({ id: 'c2', description: 'C2', impl: () => true }),
         ],
-        meta: { version: "1.0.0" },
+        meta: { version: '1.0.0' },
       });
 
       const registry = new PraxisRegistry();
@@ -295,8 +295,8 @@ describe("Edge Cases and Failure Paths", () => {
     });
   });
 
-  describe("Context and State Edge Cases", () => {
-    it("should handle empty events array", () => {
+  describe('Context and State Edge Cases', () => {
+    it('should handle empty events array', () => {
       const registry = new PraxisRegistry<{ value: number }>();
       const engine = createPraxisEngine({
         initialContext: { value: 0 },
@@ -308,7 +308,7 @@ describe("Edge Cases and Failure Paths", () => {
       expect(result.diagnostics).toHaveLength(0);
     });
 
-    it("should handle complex nested context", () => {
+    it('should handle complex nested context', () => {
       interface ComplexContext {
         nested: {
           deep: {
@@ -319,13 +319,13 @@ describe("Edge Cases and Failure Paths", () => {
         map: Map<string, number>;
       }
 
-      const TestEvent = defineEvent<"TEST", {}>("TEST");
+      const TestEvent = defineEvent<'TEST', {}>('TEST');
       const rule = defineRule<ComplexContext>({
-        id: "complex.rule",
-        description: "Complex context rule",
+        id: 'complex.rule',
+        description: 'Complex context rule',
         impl: (state) => {
           state.context.nested.deep.value += 1;
-          state.context.nested.deep.array.push("item");
+          state.context.nested.deep.array.push('item');
           return [];
         },
       });
@@ -341,7 +341,7 @@ describe("Edge Cases and Failure Paths", () => {
               array: [],
             },
           },
-          map: new Map([["key", 1]]),
+          map: new Map([['key', 1]]),
         },
         registry,
       });
@@ -353,11 +353,9 @@ describe("Edge Cases and Failure Paths", () => {
       expect(context.nested.deep.array).toHaveLength(1);
     });
 
-    it("should handle null and undefined in payloads", () => {
-      const NullFact = defineFact<"NullFact", { value: null }>("NullFact");
-      const UndefinedFact = defineFact<"UndefinedFact", { value: undefined }>(
-        "UndefinedFact"
-      );
+    it('should handle null and undefined in payloads', () => {
+      const NullFact = defineFact<'NullFact', { value: null }>('NullFact');
+      const UndefinedFact = defineFact<'UndefinedFact', { value: undefined }>('UndefinedFact');
 
       const fact1 = NullFact.create({ value: null });
       const fact2 = UndefinedFact.create({ value: undefined });
@@ -366,13 +364,13 @@ describe("Edge Cases and Failure Paths", () => {
       expect(fact2.payload.value).toBeUndefined();
     });
 
-    it("should handle large number of facts", () => {
-      const TestEvent = defineEvent<"TEST", {}>("TEST");
-      const TestFact = defineFact<"TestFact", { index: number }>("TestFact");
+    it('should handle large number of facts', () => {
+      const TestEvent = defineEvent<'TEST', {}>('TEST');
+      const TestFact = defineFact<'TestFact', { index: number }>('TestFact');
 
       const rule = defineRule<{ count: number }>({
-        id: "many.facts",
-        description: "Generate many facts",
+        id: 'many.facts',
+        description: 'Generate many facts',
         impl: (_state, events) => {
           if (events.some(TestEvent.is)) {
             const facts = [];
@@ -397,7 +395,7 @@ describe("Edge Cases and Failure Paths", () => {
       expect(result.state.facts).toHaveLength(1000);
     });
 
-    it("should isolate context mutations between getContext calls", () => {
+    it('should isolate context mutations between getContext calls', () => {
       const registry = new PraxisRegistry<{ value: number }>();
       const engine = createPraxisEngine({
         initialContext: { value: 10 },
@@ -412,14 +410,14 @@ describe("Edge Cases and Failure Paths", () => {
     });
   });
 
-  describe("Event Processing Edge Cases", () => {
-    it("should handle duplicate events", () => {
-      const TestEvent = defineEvent<"TEST", { id: string }>("TEST");
-      const TestFact = defineFact<"TestFact", { count: number }>("TestFact");
+  describe('Event Processing Edge Cases', () => {
+    it('should handle duplicate events', () => {
+      const TestEvent = defineEvent<'TEST', { id: string }>('TEST');
+      const TestFact = defineFact<'TestFact', { count: number }>('TestFact');
 
       const rule = defineRule<{ count: number }>({
-        id: "count.events",
-        description: "Count test events",
+        id: 'count.events',
+        description: 'Count test events',
         impl: (_state, events) => {
           const testEvents = events.filter(TestEvent.is);
           if (testEvents.length > 0) {
@@ -437,20 +435,20 @@ describe("Edge Cases and Failure Paths", () => {
         registry,
       });
 
-      const event = TestEvent.create({ id: "test" });
+      const event = TestEvent.create({ id: 'test' });
       const result = engine.step([event, event, event]);
 
-      const fact = result.state.facts.find((f) => f.tag === "TestFact");
+      const fact = result.state.facts.find((f) => f.tag === 'TestFact');
       expect(fact?.payload).toEqual({ count: 3 });
     });
 
-    it("should handle events with empty payloads", () => {
-      const EmptyEvent = defineEvent<"EMPTY", {}>("EMPTY");
-      const EmptyFact = defineFact<"EmptyFact", {}>("EmptyFact");
+    it('should handle events with empty payloads', () => {
+      const EmptyEvent = defineEvent<'EMPTY', {}>('EMPTY');
+      const EmptyFact = defineFact<'EmptyFact', {}>('EmptyFact');
 
       const rule = defineRule<{ triggered: boolean }>({
-        id: "empty.rule",
-        description: "Handle empty events",
+        id: 'empty.rule',
+        description: 'Handle empty events',
         impl: (state, events) => {
           if (events.some(EmptyEvent.is)) {
             state.context.triggered = true;