depa-actor 0.1.2 → 0.2.1

package/src/pipeline/ActorPipeline.ts

@@ -1,74 +1,106 @@
 /**
  * depa-actor — ActorPipeline
  *
- * Adapts the DOP 6-step pipeline (from depa-processor) to actor context.
+ * Adapts the DOP 6-step pipeline to actor context by REUSING the depa-processor
+ * `component` primitives (DEPA dimension chain Processor → Actor): the 6-step
+ * orchestration is delegated to `runByFuncStyleAdapter`, identity/null seams come
+ * from `stdMake*`, and the core-logic seam is `StdInnerLogic` verbatim — this module
+ * no longer re-implements a parallel copy of `component/types.ts`.
  *
- * Mapping:
+ * Mapping (outer dimension):
  *   OuterRuntime = ActorSelf
  *   OuterInput   = envelope payload
  *   OuterConfig  = actor state
  *
+ * Step 6 (output) is adapted with `TOuterOutput = void`: actor output is a side
+ * effect (write `self.state` / `self.send`), not a returned value. This thinly
+ * adapts depa-processor's pure-function `StdOuterOutputAdapter` without leaking
+ * actor semantics back into the generic primitive.
+ *
  * createPipelineHandler() wraps a pipeline definition into an ActorHandler.
  */
 
+import { runByFuncStyleAdapter } from 'depa-processor';
+import type {
+  StdOuterComputedAdapter,
+  StdInnerRuntimeAdapter,
+  StdInnerInputAdapter,
+  StdInnerConfigAdapter,
+  StdInnerLogic,
+  StdOuterOutputAdapter,
+} from 'depa-processor';
 import type {
   MailboxSchema,
   ActorSelf,
   ActorHandler,
-} from '../core/types';
+} from '../core/types.js';
 
 // ─── Pipeline Adapter Types ──────────────────────────────────────────
+// Thin actor-flavoured aliases over the depa-processor component adapters.
+// Outer dimension = (ActorSelf, payload, state); the seam contracts are reused
+// 1:1 from `depa-processor` rather than re-declared.
 
 export type PipelineDerivedAdapter<
   TRuntime, TSchema extends MailboxSchema, TState, TDerived,
-> = (
-  self: ActorSelf<TRuntime, TSchema, TState>,
-  payload: TSchema[keyof TSchema & string],
-  state: TState,
-) => TDerived;
+> = StdOuterComputedAdapter<
+  ActorSelf<TRuntime, TSchema, TState>,
+  TSchema[keyof TSchema & string],
+  TState,
+  TDerived
+>;
 
 export type PipelineInnerRuntimeAdapter<
   TRuntime, TSchema extends MailboxSchema, TState, TDerived, TInnerRuntime,
-> = (
-  self: ActorSelf<TRuntime, TSchema, TState>,
-  payload: TSchema[keyof TSchema & string],
-  state: TState,
-  derived: TDerived,
-) => TInnerRuntime;
+> = StdInnerRuntimeAdapter<
+  ActorSelf<TRuntime, TSchema, TState>,
+  TSchema[keyof TSchema & string],
+  TState,
+  TDerived,
+  TInnerRuntime
+>;
 
 export type PipelineInnerInputAdapter<
   TRuntime, TSchema extends MailboxSchema, TState, TDerived, TInnerInput,
-> = (
-  self: ActorSelf<TRuntime, TSchema, TState>,
-  payload: TSchema[keyof TSchema & string],
-  state: TState,
-  derived: TDerived,
-) => TInnerInput;
+> = StdInnerInputAdapter<
+  ActorSelf<TRuntime, TSchema, TState>,
+  TSchema[keyof TSchema & string],
+  TState,
+  TDerived,
+  TInnerInput
+>;
 
 export type PipelineInnerConfigAdapter<
   TRuntime, TSchema extends MailboxSchema, TState, TDerived, TInnerConfig,
-> = (
-  self: ActorSelf<TRuntime, TSchema, TState>,
-  payload: TSchema[keyof TSchema & string],
-  state: TState,
-  derived: TDerived,
-) => TInnerConfig;
+> = StdInnerConfigAdapter<
+  ActorSelf<TRuntime, TSchema, TState>,
+  TSchema[keyof TSchema & string],
+  TState,
+  TDerived,
+  TInnerConfig
+>;
 
-export type PipelineCoreLogic<TInnerRuntime, TInnerInput, TInnerConfig, TInnerOutput> = (
-  runtime: TInnerRuntime,
-  input: TInnerInput,
-  config: TInnerConfig,
-) => TInnerOutput | Promise<TInnerOutput>;
+/**
+ * Core business logic seam — reuses depa-processor `StdInnerLogic` verbatim:
+ * (runtime, input, config) => output | Promise<output>.
+ */
+export type PipelineCoreLogic<TInnerRuntime, TInnerInput, TInnerConfig, TInnerOutput> =
+  StdInnerLogic<TInnerRuntime, TInnerInput, TInnerConfig, TInnerOutput>;
 
+/**
+ * Step 6 output adapter — actor variant with `TOuterOutput = void`.
+ * The adapter performs side effects (write state / send messages) and returns
+ * nothing. This is the depa-processor `StdOuterOutputAdapter` specialised to void.
+ */
 export type PipelineOutputAdapter<
   TRuntime, TSchema extends MailboxSchema, TState, TDerived, TInnerOutput,
-> = (
-  self: ActorSelf<TRuntime, TSchema, TState>,
-  payload: TSchema[keyof TSchema & string],
-  state: TState,
-  derived: TDerived,
-  innerOutput: TInnerOutput,
-) => void | Promise<void>;
+> = StdOuterOutputAdapter<
+  ActorSelf<TRuntime, TSchema, TState>,
+  TSchema[keyof TSchema & string],
+  TState,
+  TDerived,
+  TInnerOutput,
+  void | Promise<void>
+>;
 
 // ─── Pipeline Definition ─────────────────────────────────────────────
 
@@ -92,6 +124,14 @@ export interface ActorPipelineDef<
 
 // ─── createPipelineHandler ───────────────────────────────────────────
 
+/**
+ * Wrap a pipeline definition into an ActorHandler by delegating the 6-step
+ * orchestration to depa-processor `runByFuncStyleAdapter`.
+ *
+ * Outer dimension: runtime = self, input = payload, config = state.
+ * Step 6 produces `void` — `runByFuncStyleAdapter` runs the output adapter for its
+ * side effects and the (void) return value is discarded.
+ */
 export function createPipelineHandler<
   TRuntime,
   TSchema extends MailboxSchema,
@@ -108,25 +148,31 @@ export function createPipelineHandler<
   >,
 ): ActorHandler<TRuntime, TSchema, TState> {
   return async (self, envelope) => {
-    const payload = envelope.payload;
-    const state = self.state;
-
-    // Step 1: Compute derived
-    const derived = pipeline.computeDerived(self, payload, state);
-
-    // Step 2: Transform runtime
-    const innerRuntime = pipeline.innerRuntime(self, payload, state, derived);
-
-    // Step 3: Transform input
-    const innerInput = pipeline.innerInput(self, payload, state, derived);
-
-    // Step 4: Transform config
-    const innerConfig = pipeline.innerConfig(self, payload, state, derived);
-
-    // Step 5: Core logic
-    const innerOutput = await pipeline.coreLogic(innerRuntime, innerInput, innerConfig);
-
-    // Step 6: Output (side effects on actor state / send messages)
-    await pipeline.output(self, payload, state, derived, innerOutput);
+    // `runByFuncStyleAdapter` returns the output adapter's value verbatim (without
+    // awaiting it). Capture it and await so an async step-6 side effect (write
+    // state / send messages) is fully settled before the handler resolves —
+    // preserving the original `await pipeline.output(...)` semantics.
+    const outputResult = await runByFuncStyleAdapter<
+      ActorSelf<TRuntime, TSchema, TState>,
+      TSchema[keyof TSchema & string],
+      TState,
+      TDerived,
+      void | Promise<void>,
+      TInnerRuntime,
+      TInnerInput,
+      TInnerConfig,
+      TInnerOutput
+    >(
+      self,
+      envelope.payload,
+      self.state,
+      pipeline.computeDerived,
+      pipeline.innerRuntime,
+      pipeline.innerInput,
+      pipeline.innerConfig,
+      pipeline.coreLogic,
+      pipeline.output,
+    );
+    await outputResult;
   };
 }

package/src/runtime/ActorRuntime.ts

@@ -12,8 +12,8 @@ import type {
   ActorDef,
   ActorRef,
   ActorLogEntry,
-} from '../core/types';
-import { ActorSystem } from '../core/ActorSystem';
+} from '../core/types.js';
+import { ActorSystem } from '../core/ActorSystem.js';
 
 // ─── Plugin ──────────────────────────────────────────────────────────