@almadar/runtime 2.6.1 → 2.7.0

package/dist/{OrbitalServerRuntime-B-QeKtKd.d.ts → OrbitalServerRuntime-CJYMN0d3.d.ts}

@@ -1,6 +1,6 @@
 import { Router } from 'express';
-import { I as IEventBus, f as RuntimeEvent, e as EventListener, U as Unsubscribe, T as TraitDefinition, R as RuntimeConfig, h as TransitionObserver, g as TraitState, i as TransitionResult, d as Effect, E as EffectHandlers } from './types-DYcUvi4H.js';
-import { EventPayload, EntityRow, OrbitalSchema, Orbital, Trait } from '@almadar/core';
+import { I as IEventBus, g as RuntimeEvent, f as EventListener, U as Unsubscribe, T as TraitDefinition, R as RuntimeConfig, i as TransitionObserver, h as TraitState, j as TransitionResult, E as EvaluationContextExtensions, a as EffectHandlers } from './types-CvYnmqkg.js';
+import { EventPayload, EntityRow, OrbitalSchema, Orbital, Trait, OrbitalDefinition, Entity, TraitTick } from '@almadar/core';
 
 /**
  * EventBus - Platform-Agnostic Pub/Sub Implementation
@@ -126,6 +126,11 @@ interface ProcessEventOptions {
      * When true, log warnings when bindings resolve to undefined. (RCG-01)
      */
     strictBindings?: boolean;
+    /**
+     * Additional fields to spread onto EvaluationContext for guard evaluation.
+     * Used to inject module contexts (e.g., { agent: AgentContext }).
+     */
+    contextExtensions?: EvaluationContextExtensions;
 }
 /**
  * Process an event through a trait's state machine.
@@ -238,6 +243,48 @@ declare class StateMachineManager {
     resetAll(): void;
 }
 
+/**
+ * LocalPersistenceAdapter - Filesystem CRUD for `persistence: "local"` entities.
+ *
+ * One directory per entity type, one JSON file per instance.
+ * Language-level feature: benefits all .orb programs, not just the agent.
+ * Offline-first apps, CLI tools, config managers, local databases all use it.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Filesystem-backed persistence adapter.
+ *
+ * Storage layout:
+ * ```
+ * {root}/
+ *   {entityType}/
+ *     {id}.json
+ * ```
+ */
+declare class LocalPersistenceAdapter implements PersistenceAdapter {
+    private readonly root;
+    constructor(root: string);
+    private entityDir;
+    private filePath;
+    create(entityType: string, data: EntityRow): Promise<{
+        id: string;
+    }>;
+    update(entityType: string, id: string, data: EntityRow): Promise<void>;
+    delete(entityType: string, id: string): Promise<void>;
+    getById(entityType: string, id: string): Promise<EntityRow | null>;
+    list(entityType: string): Promise<EntityRow[]>;
+    /**
+     * Remove all data for an entity type.
+     */
+    clear(entityType: string): Promise<void>;
+    /**
+     * Remove all local data.
+     */
+    clearAll(): Promise<void>;
+}
+
 /**
  * External Orbital Loader
  *
@@ -575,75 +622,23 @@ declare function parseNamespacedEvent(eventName: string): {
  * @packageDocumentation
  */
 
-/**
- * Simplified OrbitalSchema for runtime registration
- * (Subset of full OrbitalSchema - just what's needed for execution)
- */
-interface RuntimeOrbitalSchema {
-    name: string;
-    version?: string;
-    orbitals: RuntimeOrbital[];
-}
-interface RuntimeOrbital {
-    name: string;
-    entity: {
-        name: string;
-        fields?: Array<{
-            name: string;
-            type: string;
-            relation?: {
-                entity?: string;
-                cardinality?: string;
-                onDelete?: string;
-            };
-        }>;
-        /** Pre-defined entity instances to seed on registration */
-        instances?: Array<EntityRow>;
-    };
-    traits: RuntimeTrait[];
-}
-/**
- * Tick definition for scheduled effects
- */
-interface RuntimeTraitTick {
-    /** Unique name for this tick */
-    name: string;
-    /** Interval in milliseconds, or cron expression string */
-    interval: number | string;
-    /** Guard condition (S-expression) - tick only executes if guard passes */
-    guard?: unknown;
-    /** Effects to execute when tick fires */
-    effects: Effect[];
-    /** Filter to specific entity IDs (optional) */
-    appliesTo?: string[];
-}
-interface RuntimeTrait {
-    name: string;
-    states: Array<{
-        name: string;
-        isInitial?: boolean;
-    }>;
-    transitions: Array<{
-        from: string;
-        to: string;
-        event: string;
-        guard?: unknown;
-        effects?: Effect[];
-    }>;
-    listens?: Array<{
-        event: string;
-        triggers: string;
-        payloadMapping?: EventPayload;
-    }>;
-    emits?: string[];
-    /** Scheduled ticks for this trait */
-    ticks?: RuntimeTraitTick[];
-}
+/** @deprecated Use OrbitalSchema from @almadar/core */
+type RuntimeOrbitalSchema = OrbitalSchema;
+/** @deprecated Use OrbitalDefinition from @almadar/core */
+type RuntimeOrbital = OrbitalDefinition;
+/** @deprecated Use Trait from @almadar/core */
+type RuntimeTrait = Trait;
+/** @deprecated Use TraitTick from @almadar/core */
+type RuntimeTraitTick = TraitTick;
 /**
  * Registered orbital with runtime state
  */
 interface RegisteredOrbital {
-    schema: RuntimeOrbital;
+    schema: OrbitalDefinition;
+    /** Resolved entity (never a string ref at runtime) */
+    entity: Entity;
+    /** Resolved inline traits (string refs filtered out) */
+    traits: Trait[];
     manager: StateMachineManager;
     entityData: Map<string, EntityRow>;
 }
@@ -694,8 +689,12 @@ interface EffectResult {
     action?: string;
     /** Entity type affected (for persist/set/ref/deref/swap) */
     entityType?: string;
-    /** Result data from the effect */
-    data?: EntityRow;
+    /** Result data from the effect (entity row for CRUD, summary for batch) */
+    data?: EntityRow | {
+        operations: EntityRow[];
+        completedCount: number;
+        totalCount: number;
+    };
     /** Whether the effect succeeded */
     success: boolean;
     /** Error message if failed */
@@ -750,6 +749,17 @@ interface OrbitalServerRuntimeConfig {
      * Default: true
      */
     namespaceEvents?: boolean;
+    /**
+     * Root directory for `persistence: "local"` entities.
+     * Default: ~/.orb/data/
+     */
+    localStorageRoot?: string;
+    /**
+     * Additional fields to spread onto every EvaluationContext.
+     * Use this to inject module contexts (e.g., { agent: AgentContext }).
+     * The evaluator dispatches agent/* operators to ctx.agent.
+     */
+    contextExtensions?: EvaluationContextExtensions;
 }
 /**
  * Adapter for persisting entity data
@@ -775,6 +785,7 @@ declare class OrbitalServerRuntime {
     private entitySharingMap;
     private eventNamespaceMap;
     private osHandlers;
+    private localPersistence;
     constructor(config?: OrbitalServerRuntimeConfig);
     /**
      * Register an OrbitalSchema for execution.
@@ -784,13 +795,13 @@ declare class OrbitalServerRuntime {
      *
      * For explicit preprocessing control, use `registerWithPreprocess()`.
      */
-    register(schema: RuntimeOrbitalSchema): Promise<void>;
+    register(schema: OrbitalSchema): Promise<void>;
     /**
      * Register an OrbitalSchema synchronously (for backward compatibility).
      * Note: This version doesn't wait for instance seeding to complete.
      * Use async register() for guaranteed instance seeding.
      */
-    registerSync(schema: RuntimeOrbitalSchema): void;
+    registerSync(schema: OrbitalSchema): void;
     /**
      * Register an OrbitalSchema with preprocessing to resolve `uses` imports.
      *
@@ -820,7 +831,7 @@ declare class OrbitalServerRuntime {
      * }
      * ```
      */
-    registerWithPreprocess(schema: RuntimeOrbitalSchema, options?: {
+    registerWithPreprocess(schema: OrbitalSchema, options?: {
         sourcePath?: string;
     }): Promise<{
         success: boolean;
@@ -954,4 +965,4 @@ declare class OrbitalServerRuntime {
  */
 declare function createOrbitalServerRuntime(config?: OrbitalServerRuntimeConfig): OrbitalServerRuntime;
 
-export { type EntitySharingMap as E, type LoaderConfig as L, type OrbitalEventRequest as O, type PersistenceAdapter as P, type RegisteredOrbital as R, StateMachineManager as S, EventBus as a, type EventNamespaceMap as b, type OrbitalEventResponse as c, type OrbitalServerRuntimeConfig as d, type PreprocessOptions as e, type PreprocessResult as f, type PreprocessedSchema as g, type ProcessEventOptions as h, type RuntimeOrbital as i, type RuntimeOrbitalSchema as j, type RuntimeTrait as k, createInitialTraitState as l, findInitialState as m, findTransition as n, getIsolatedCollectionName as o, getNamespacedEvent as p, isNamespacedEvent as q, normalizeEventKey as r, parseNamespacedEvent as s, preprocessSchema as t, processEvent as u, type EffectResult as v, OrbitalServerRuntime as w, type RuntimeTraitTick as x, createOrbitalServerRuntime as y };
+export { type EntitySharingMap as E, type LoaderConfig as L, type OrbitalEventRequest as O, type PersistenceAdapter as P, type RegisteredOrbital as R, StateMachineManager as S, EventBus as a, type EventNamespaceMap as b, type OrbitalEventResponse as c, type OrbitalServerRuntimeConfig as d, type PreprocessOptions as e, type PreprocessResult as f, type PreprocessedSchema as g, type ProcessEventOptions as h, type RuntimeOrbital as i, type RuntimeOrbitalSchema as j, type RuntimeTrait as k, createInitialTraitState as l, findInitialState as m, findTransition as n, getIsolatedCollectionName as o, getNamespacedEvent as p, isNamespacedEvent as q, normalizeEventKey as r, parseNamespacedEvent as s, preprocessSchema as t, processEvent as u, type EffectResult as v, LocalPersistenceAdapter as w, OrbitalServerRuntime as x, type RuntimeTraitTick as y, createOrbitalServerRuntime as z };

package/dist/OrbitalServerRuntime.d.ts

@@ -1,4 +1,4 @@
 import 'express';
-export { v as EffectResult, L as LoaderConfig, O as OrbitalEventRequest, c as OrbitalEventResponse, w as OrbitalServerRuntime, d as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, i as RuntimeOrbital, j as RuntimeOrbitalSchema, k as RuntimeTrait, x as RuntimeTraitTick, y as createOrbitalServerRuntime } from './OrbitalServerRuntime-B-QeKtKd.js';
-import './types-DYcUvi4H.js';
+export { v as EffectResult, L as LoaderConfig, w as LocalPersistenceAdapter, O as OrbitalEventRequest, c as OrbitalEventResponse, x as OrbitalServerRuntime, d as OrbitalServerRuntimeConfig, P as PersistenceAdapter, R as RegisteredOrbital, i as RuntimeOrbital, j as RuntimeOrbitalSchema, k as RuntimeTrait, y as RuntimeTraitTick, z as createOrbitalServerRuntime } from './OrbitalServerRuntime-CJYMN0d3.js';
+import './types-CvYnmqkg.js';
 import '@almadar/core';

package/dist/OrbitalServerRuntime.js

@@ -1,11 +1,85 @@
-import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-ESNML4B4.js';
+import { EventBus, createUnifiedLoader, preprocessSchema, StateMachineManager, createContextFromBindings, EffectExecutor } from './chunk-ZYH3XSOL.js';
 import { Router } from 'express';
+import * as fs from 'fs';
+import fs__default from 'fs';
+import path from 'path';
 import { evaluateGuard, evaluate } from '@almadar/evaluator';
+import { isInlineTrait } from '@almadar/core';
 import { faker } from '@faker-js/faker';
-import * as fs from 'fs';
 import * as net from 'net';
 import { execSync } from 'child_process';
 
+var LocalPersistenceAdapter = class {
+  root;
+  constructor(root) {
+    this.root = root;
+    fs__default.mkdirSync(root, { recursive: true });
+  }
+  entityDir(entityType) {
+    const dir = path.join(this.root, entityType.toLowerCase());
+    fs__default.mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+  filePath(entityType, id) {
+    return path.join(this.entityDir(entityType), `${id}.json`);
+  }
+  async create(entityType, data) {
+    const id = data.id || `${entityType.toLowerCase()}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const record = { ...data, id };
+    const filePath = this.filePath(entityType, id);
+    fs__default.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
+    return { id };
+  }
+  async update(entityType, id, data) {
+    const filePath = this.filePath(entityType, id);
+    let existing = { id };
+    if (fs__default.existsSync(filePath)) {
+      existing = JSON.parse(fs__default.readFileSync(filePath, "utf-8"));
+    }
+    const merged = { ...existing, ...data, id };
+    fs__default.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  async delete(entityType, id) {
+    const filePath = this.filePath(entityType, id);
+    if (fs__default.existsSync(filePath)) {
+      fs__default.unlinkSync(filePath);
+    }
+  }
+  async getById(entityType, id) {
+    const filePath = this.filePath(entityType, id);
+    if (!fs__default.existsSync(filePath)) return null;
+    return JSON.parse(fs__default.readFileSync(filePath, "utf-8"));
+  }
+  async list(entityType) {
+    const dir = this.entityDir(entityType);
+    if (!fs__default.existsSync(dir)) return [];
+    const files = fs__default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const results = [];
+    for (const file of files) {
+      const content = fs__default.readFileSync(path.join(dir, file), "utf-8");
+      results.push(JSON.parse(content));
+    }
+    return results;
+  }
+  /**
+   * Remove all data for an entity type.
+   */
+  async clear(entityType) {
+    const dir = path.join(this.root, entityType.toLowerCase());
+    if (fs__default.existsSync(dir)) {
+      fs__default.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  /**
+   * Remove all local data.
+   */
+  async clearAll() {
+    if (fs__default.existsSync(this.root)) {
+      fs__default.rmSync(this.root, { recursive: true, force: true });
+      fs__default.mkdirSync(this.root, { recursive: true });
+    }
+  }
+};
 var MockPersistenceAdapter = class {
   stores = /* @__PURE__ */ new Map();
   schemas = /* @__PURE__ */ new Map();
@@ -562,6 +636,7 @@ var OrbitalServerRuntime = class {
   entitySharingMap = {};
   eventNamespaceMap = {};
   osHandlers = null;
+  localPersistence = null;
   constructor(config = {}) {
     this.config = {
       mode: "mock",
@@ -590,6 +665,9 @@ var OrbitalServerRuntime = class {
     } else {
       this.persistence = config.persistence || new InMemoryPersistence();
     }
+    if (config.localStorageRoot) {
+      this.localPersistence = new LocalPersistenceAdapter(config.localStorageRoot);
+    }
     this.osHandlers = createOsHandlers({
       emitEvent: (type, payload) => this.eventBus.emit(type, payload)
     });
@@ -744,10 +822,11 @@ var OrbitalServerRuntime = class {
    * Register a single orbital
    */
   async registerOrbitalAsync(orbital) {
-    const traitDefs = (orbital.traits || []).map((t) => {
-      const stateMachine = t.stateMachine;
-      const states = t.states || stateMachine?.states || [];
-      const transitions = t.transitions || stateMachine?.transitions || [];
+    const inlineTraits = (orbital.traits || []).filter(isInlineTrait);
+    const traitDefs = inlineTraits.map((t) => {
+      const sm = t.stateMachine;
+      const states = sm?.states || [];
+      const transitions = sm?.transitions || [];
       return {
         name: t.name,
         states,
@@ -755,13 +834,18 @@ var OrbitalServerRuntime = class {
         listens: t.listens
       };
     });
-    const manager = new StateMachineManager(traitDefs);
+    const manager = new StateMachineManager(traitDefs, {
+      contextExtensions: this.config.contextExtensions
+    });
+    const entityRef = orbital.entity;
+    const entity = typeof entityRef === "string" ? { name: entityRef, fields: [] } : entityRef;
     this.orbitals.set(orbital.name, {
       schema: orbital,
+      entity,
+      traits: inlineTraits,
       manager,
       entityData: /* @__PURE__ */ new Map()
     });
-    const entity = orbital.entity;
     if (entity?.name && entity.instances && Array.isArray(entity.instances)) {
       const instances = entity.instances;
       if (instances.length > 0) {
@@ -822,7 +906,7 @@ var OrbitalServerRuntime = class {
     }
     this.listenerCleanups = [];
     for (const [orbitalName, registered] of this.orbitals) {
-      for (const trait of registered.schema.traits || []) {
+      for (const trait of registered.traits) {
         if (!trait.listens) continue;
         for (const listener of trait.listens) {
           const cleanup = this.eventBus.on(listener.event, async (event) => {
@@ -861,7 +945,7 @@ var OrbitalServerRuntime = class {
   setupTicks() {
     this.cleanupTicks();
     for (const [orbitalName, registered] of this.orbitals) {
-      for (const trait of registered.schema.traits || []) {
+      for (const trait of registered.traits || []) {
         if (!trait.ticks || trait.ticks.length === 0) continue;
         for (const tick of trait.ticks) {
           this.registerTick(orbitalName, trait.name, tick, registered);
@@ -932,7 +1016,7 @@ var OrbitalServerRuntime = class {
    * Execute a tick for all applicable entities
    */
   async executeTick(orbitalName, traitName, tick, registered) {
-    const entityType = registered.schema.entity.name;
+    const entityType = registered.entity.name;
     const emittedEvents = [];
     try {
       let entities = await this.persistence.list(entityType);
@@ -952,7 +1036,7 @@ var OrbitalServerRuntime = class {
               entity,
               payload: {},
               state: registered.manager.getState(traitName)?.currentState || "unknown"
-            });
+            }, false, this.config.contextExtensions);
             const guardPasses = evaluateGuard(
               tick.guard,
               ctx
@@ -1059,7 +1143,7 @@ var OrbitalServerRuntime = class {
     let entityData = {};
     if (entityId) {
       const stored = await this.persistence.getById(
-        registered.schema.entity.name,
+        registered.entity.name,
         entityId
       );
       if (stored) {
@@ -1095,9 +1179,8 @@ var OrbitalServerRuntime = class {
       }
     }
     const refTypes = /* @__PURE__ */ new Set();
-    for (const trait of registered.schema.traits || []) {
-      const sm = trait.stateMachine;
-      const transitions = sm?.transitions ?? trait.transitions ?? [];
+    for (const trait of registered.traits) {
+      const transitions = trait.stateMachine?.transitions ?? [];
       for (const trans of transitions) {
         for (const eff of trans.effects ?? []) {
           if (Array.isArray(eff) && eff[0] === "ref" && typeof eff[1] === "string") {
@@ -1140,7 +1223,7 @@ var OrbitalServerRuntime = class {
    * Execute effects from a transition
    */
   async executeEffects(registered, traitName, effects, payload, entityData, entityId, emittedEvents, fetchedData, clientEffects, effectResults, user) {
-    const entityType = registered.schema.entity.name;
+    const entityType = registered.entity.name;
     let bindingsRef = null;
     let contextRef = null;
     const handlers = {
@@ -1430,7 +1513,7 @@ var OrbitalServerRuntime = class {
             current,
             entity: entityData,
             payload
-          });
+          }, false, this.config.contextExtensions);
           let newData;
           if (Array.isArray(transform)) {
             const result = evaluate(
@@ -1483,7 +1566,8 @@ var OrbitalServerRuntime = class {
           handlers,
           bindings: bindingsRef ?? {},
           context: contextRef ?? { traitName, state: "unknown", transition: "unknown" },
-          debug: this.config.debug
+          debug: this.config.debug,
+          contextExtensions: this.config.contextExtensions
         });
         for (const innerEffect of atomicEffects) {
           if (atomicFailed) break;
@@ -1512,8 +1596,8 @@ var OrbitalServerRuntime = class {
       renderUI: (slot, pattern, props, priority) => {
         clientEffects.push(["render-ui", slot, pattern, props, priority]);
       },
-      navigate: (path, params) => {
-        clientEffects.push(["navigate", path, params]);
+      navigate: (path2, params) => {
+        clientEffects.push(["navigate", path2, params]);
       },
       notify: (message, type) => {
         if (this.config.debug) {
@@ -1551,7 +1635,8 @@ var OrbitalServerRuntime = class {
       handlers,
       bindings,
       context,
-      debug: this.config.debug
+      debug: this.config.debug,
+      contextExtensions: this.config.contextExtensions
     });
     await executor.executeAll(effects);
   }
@@ -1574,8 +1659,8 @@ var OrbitalServerRuntime = class {
    */
   validateRelationCardinality(entityType, data) {
     for (const [, registered] of this.orbitals) {
-      if (registered.schema.entity.name !== entityType) continue;
-      for (const field of registered.schema.entity.fields ?? []) {
+      if (registered.entity.name !== entityType) continue;
+      for (const field of registered.entity.fields ?? []) {
         if (field.type !== "relation") continue;
         const value = data[field.name];
         if (value === void 0 || value === null) continue;
@@ -1609,13 +1694,13 @@ var OrbitalServerRuntime = class {
    */
   async enforceOnDeleteRules(entityType, deletedId) {
     for (const [, registered] of this.orbitals) {
-      const schema = registered.schema;
-      const fields = schema.entity.fields ?? [];
+      const entity = registered.entity;
+      const fields = entity.fields ?? [];
       for (const field of fields) {
         if (field.type !== "relation") continue;
         if (field.relation?.entity !== entityType) continue;
         const onDelete = field.relation.onDelete || "restrict";
-        const referringEntityType = schema.entity.name;
+        const referringEntityType = entity.name;
         const allRecords = await this.persistence.list(referringEntityType);
         const affectedRecords = allRecords.filter((record) => {
           const fkValue = record[field.name];
@@ -1673,8 +1758,8 @@ var OrbitalServerRuntime = class {
     visited.add(entityType);
     let entityFields;
     for (const [, registered] of this.orbitals) {
-      if (registered.schema.entity.name === entityType) {
-        entityFields = registered.schema.entity.fields;
+      if (registered.entity.name === entityType) {
+        entityFields = registered.entity.fields;
         break;
       }
     }
@@ -1728,17 +1813,31 @@ var OrbitalServerRuntime = class {
       const populatedFieldName = includeField.endsWith("Id") ? includeField.slice(0, -2) : includeField;
       for (const entity of entities) {
         const fkValue = entity[foreignKeyField];
-        const entityRecord = entity;
         if (cardinality === "one" || cardinality === "many-to-one") {
           if (typeof fkValue === "string" && relatedEntities.has(fkValue)) {
-            entityRecord[populatedFieldName] = relatedEntities.get(fkValue);
+            Object.defineProperty(entity, populatedFieldName, {
+              value: relatedEntities.get(fkValue),
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
           }
         } else {
           if (Array.isArray(fkValue)) {
             const fkIds = fkValue.filter((id) => typeof id === "string");
-            entityRecord[populatedFieldName] = fkIds.map((id) => relatedEntities.get(id)).filter(Boolean);
+            Object.defineProperty(entity, populatedFieldName, {
+              value: fkIds.map((id) => relatedEntities.get(id)).filter(Boolean),
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
           } else if (typeof fkValue === "string" && relatedEntities.has(fkValue)) {
-            entityRecord[populatedFieldName] = [relatedEntities.get(fkValue)];
+            Object.defineProperty(entity, populatedFieldName, {
+              value: [relatedEntities.get(fkValue)],
+              writable: true,
+              enumerable: true,
+              configurable: true
+            });
           }
         }
       }
@@ -1767,8 +1866,8 @@ var OrbitalServerRuntime = class {
       const orbitals = Array.from(this.orbitals.entries()).map(
         ([name, reg]) => ({
           name,
-          entity: reg.schema.entity?.name,
-          traits: (reg.schema.traits || []).map((t) => t.name)
+          entity: reg.entity?.name,
+          traits: (reg.traits || []).map((t) => t.name)
         })
       );
       res.json({ success: true, orbitals });
@@ -1788,12 +1887,12 @@ var OrbitalServerRuntime = class {
         success: true,
         orbital: {
           name: orbitalName,
-          entity: registered.schema.entity,
-          traits: (registered.schema.traits || []).map((t) => ({
+          entity: registered.entity,
+          traits: registered.traits.map((t) => ({
             name: t.name,
             currentState: states[t.name],
-            states: (t.states || []).map((s) => s.name),
-            events: [...new Set((t.transitions || []).map((tr) => tr.event))]
+            states: (t.stateMachine?.states || []).map((s) => s.name),
+            events: [...new Set((t.stateMachine?.transitions || []).map((tr) => tr.event))]
           }))
         }
       });
@@ -1873,6 +1972,6 @@ function createOrbitalServerRuntime(config) {
   return new OrbitalServerRuntime(config);
 }
 
-export { OrbitalServerRuntime, createOrbitalServerRuntime };
+export { LocalPersistenceAdapter, OrbitalServerRuntime, createOrbitalServerRuntime };
 //# sourceMappingURL=OrbitalServerRuntime.js.map
 //# sourceMappingURL=OrbitalServerRuntime.js.map