@almadar/runtime 2.2.2 → 2.4.0

package/dist/{OrbitalServerRuntime-YLqyxdjz.d.ts → OrbitalServerRuntime-Bel-jQ_o.d.ts}

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { I as IEventBus, i as RuntimeEvent, h as EventListener, U as Unsubscribe, E as EffectHandlers, g as Effect, T as TraitState } from './types-E5o2Jqe6.js';
+import { I as IEventBus, i as RuntimeEvent, h as EventListener, U as Unsubscribe, E as EffectHandlers, g as Effect, T as TraitState } from './types-BrbvZxzX.js';
 import { OrbitalSchema, Orbital, Trait } from '@almadar/core';
 
 /**
@@ -517,10 +517,10 @@ interface OrbitalEventResponse {
  */
 interface EffectResult {
     /** Effect type that was executed */
-    effect: 'persist' | 'call-service' | 'set';
+    effect: 'persist' | 'call-service' | 'set' | 'ref' | 'deref' | 'swap' | 'atomic';
     /** Action performed (e.g., 'create', 'update', 'delete' for persist) */
     action?: string;
-    /** Entity type affected (for persist/set) */
+    /** Entity type affected (for persist/set/ref/deref/swap) */
     entityType?: string;
     /** Result data from the effect */
     data?: Record<string, unknown>;

package/dist/OrbitalServerRuntime.d.ts

@@ -1,4 +1,4 @@
 import 'express';
-export { n as EffectResult, L as LoaderConfig, O as OrbitalEventRequest, c as OrbitalEventResponse, o as OrbitalServerRuntime, d as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RuntimeOrbital, h as RuntimeOrbitalSchema, i as RuntimeTrait, q as RuntimeTraitTick, r as createOrbitalServerRuntime } from './OrbitalServerRuntime-YLqyxdjz.js';
-import './types-E5o2Jqe6.js';
+export { n as EffectResult, L as LoaderConfig, O as OrbitalEventRequest, c as OrbitalEventResponse, o as OrbitalServerRuntime, d as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RuntimeOrbital, h as RuntimeOrbitalSchema, i as RuntimeTrait, q as RuntimeTraitTick, r as createOrbitalServerRuntime } from './OrbitalServerRuntime-Bel-jQ_o.js';
+import './types-BrbvZxzX.js';
 import '@almadar/core';

package/dist/OrbitalServerRuntime.js

@@ -1,6 +1,6 @@
-import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-57PUFAKH.js';
+import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-GCRRQAGZ.js';
 import { Router } from 'express';
-import { evaluateGuard } from '@almadar/evaluator';
+import { evaluateGuard, evaluate } from '@almadar/evaluator';
 import { faker } from '@faker-js/faker';
 import * as fs from 'fs';
 import * as net from 'net';
@@ -1087,6 +1087,33 @@ var OrbitalServerRuntime = class {
         );
       }
     }
+    const persistedTypes = /* @__PURE__ */ new Set();
+    for (const er of effectResults) {
+      if ((er.effect === "persist" || er.effect === "set" || er.effect === "swap") && er.success && er.entityType) {
+        persistedTypes.add(er.entityType);
+      }
+    }
+    const refTypes = /* @__PURE__ */ new Set();
+    for (const trait of registered.schema.traits || []) {
+      const sm = trait.stateMachine;
+      const transitions = sm?.transitions ?? trait.transitions ?? [];
+      for (const trans of transitions) {
+        for (const eff of trans.effects ?? []) {
+          if (Array.isArray(eff) && eff[0] === "ref" && typeof eff[1] === "string") {
+            refTypes.add(eff[1]);
+          }
+        }
+      }
+    }
+    for (const mutatedEntityType of persistedTypes) {
+      if (refTypes.has(mutatedEntityType)) {
+        try {
+          const fresh = await this.persistence.list(mutatedEntityType);
+          fetchedData[mutatedEntityType] = fresh;
+        } catch {
+        }
+      }
+    }
     const states = {};
     for (const [name, state] of registered.manager.getAllStates()) {
       states[name] = state.currentState;
@@ -1114,6 +1141,7 @@ var OrbitalServerRuntime = class {
   async executeEffects(registered, traitName, effects, payload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user) {
     const entityType = registered.schema.entity.name;
     let bindingsRef = null;
+    let contextRef = null;
     const handlers = {
       emit: (event, eventPayload) => {
         if (this.config.debug) {
@@ -1336,6 +1364,149 @@ var OrbitalServerRuntime = class {
           return null;
         }
       },
+      // Resource operators: ref, deref, swap, watch, atomic
+      ref: async (refEntityType, options) => {
+        try {
+          return await handlers.fetch(refEntityType, options);
+        } catch (error) {
+          console.error(`[OrbitalRuntime] ref error for ${refEntityType}:`, error);
+          return null;
+        }
+      },
+      deref: async (derefEntityType, options) => {
+        try {
+          let result = null;
+          if (options?.id) {
+            const entity = await this.persistence.getById(derefEntityType, options.id);
+            if (entity) {
+              fetchedData[derefEntityType] = [entity];
+              result = entity;
+            }
+          } else {
+            const entities = await this.persistence.list(derefEntityType);
+            fetchedData[derefEntityType] = entities;
+            result = entities;
+          }
+          if (bindingsRef && result) {
+            const records = Array.isArray(result) ? result : [result];
+            if (records.length > 0) {
+              const merged = Object.assign([...records], records[0]);
+              bindingsRef[derefEntityType] = merged;
+              if (derefEntityType === entityType) {
+                bindingsRef.entity = merged;
+              }
+            }
+          }
+          effectResults.push({
+            effect: "deref",
+            entityType: derefEntityType,
+            success: true
+          });
+          return result;
+        } catch (error) {
+          effectResults.push({
+            effect: "deref",
+            entityType: derefEntityType,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return null;
+        }
+      },
+      swap: async (swapEntityType, swapEntityId, transform) => {
+        try {
+          const current = await this.persistence.getById(swapEntityType, swapEntityId);
+          if (!current) {
+            effectResults.push({
+              effect: "swap",
+              entityType: swapEntityType,
+              success: false,
+              error: `Entity ${swapEntityType}/${swapEntityId} not found`
+            });
+            return null;
+          }
+          const ctx = createContextFromBindings({
+            current,
+            entity: entityData,
+            payload
+          });
+          let newData;
+          if (Array.isArray(transform)) {
+            const result = evaluate(
+              transform,
+              ctx
+            );
+            if (result && typeof result === "object" && !Array.isArray(result)) {
+              newData = result;
+            } else {
+              newData = current;
+            }
+          } else if (typeof transform === "object" && transform !== null) {
+            newData = { ...current, ...transform };
+          } else {
+            effectResults.push({
+              effect: "swap",
+              entityType: swapEntityType,
+              success: false,
+              error: "swap! transform must be an S-expression or object"
+            });
+            return null;
+          }
+          await this.persistence.update(swapEntityType, swapEntityId, newData);
+          effectResults.push({
+            effect: "swap",
+            entityType: swapEntityType,
+            data: { id: swapEntityId, ...newData },
+            success: true
+          });
+          return newData;
+        } catch (error) {
+          effectResults.push({
+            effect: "swap",
+            entityType: swapEntityType,
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          return null;
+        }
+      },
+      watch: (_watchEntityType, _watchOptions) => {
+        if (this.config.debug) {
+          console.log(`[OrbitalRuntime] watch is a no-op on server: ${_watchEntityType}`);
+        }
+      },
+      atomic: async (atomicEffects) => {
+        let atomicFailed = false;
+        let atomicError = "";
+        const atomicExecutor = new EffectExecutor({
+          handlers,
+          bindings: bindingsRef ?? {},
+          context: contextRef ?? { traitName, state: "unknown", transition: "unknown" },
+          debug: this.config.debug
+        });
+        for (const innerEffect of atomicEffects) {
+          if (atomicFailed) break;
+          try {
+            await atomicExecutor.execute(innerEffect);
+          } catch (err) {
+            atomicFailed = true;
+            atomicError = err instanceof Error ? err.message : String(err);
+          }
+        }
+        if (atomicFailed) {
+          effectResults.push({
+            effect: "atomic",
+            success: false,
+            error: `Atomic block failed: ${atomicError}`
+          });
+        } else {
+          effectResults.push({
+            effect: "atomic",
+            success: true,
+            data: { innerCount: atomicEffects.length }
+          });
+        }
+      },
       // Client-side effects - collect for forwarding to client
       renderUI: (slot, pattern, props, priority) => {
         clientEffects.push(["render-ui", slot, pattern, props, priority]);
@@ -1374,6 +1545,7 @@ var OrbitalServerRuntime = class {
       transition: "unknown",
       entityId
     };
+    contextRef = context;
     const executor = new EffectExecutor({
       handlers,
       bindings,