depa-actor 0.1.2 → 0.2.1

package/dist-cjs/orchestration/scheduler.cjs

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeEffectivePriority = computeEffectivePriority;
+exports.selectNextFiberId = selectNextFiberId;
+exports.scheduleOne = scheduleOne;
+function isSchedulable(fiber) {
+    return fiber.status === 'ready';
+}
+function computeEffectivePriority(fiber, agingStep) {
+    return fiber.basePriority - fiber.age * Math.max(0, agingStep);
+}
+function selectNextFiberId(state, now) {
+    const hooks = state.options.schedulerHooks;
+    const selectionNow = typeof now === 'number' ? now : Date.now();
+    let candidates = Object.values(state.fibers).filter(isSchedulable);
+    if (hooks?.filterCandidates) {
+        candidates = hooks.filterCandidates({ state, candidates, now: selectionNow });
+    }
+    else if (hooks?.filterCandidate) {
+        const f = hooks.filterCandidate;
+        candidates = candidates.filter(fiber => f({ state, fiber, now: selectionNow }));
+    }
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const agingStep = state.options.agingStep;
+    candidates.sort((a, b) => {
+        const pa = computeEffectivePriority(a, agingStep);
+        const pb = computeEffectivePriority(b, agingStep);
+        if (pa !== pb) {
+            return pa - pb;
+        }
+        return a.order - b.order;
+    });
+    return candidates[0]?.id;
+}
+function scheduleOne(state, now) {
+    const selectedFiberId = selectNextFiberId(state, now);
+    if (!selectedFiberId) {
+        return { state, effects: [] };
+    }
+    const selected = state.fibers[selectedFiberId];
+    if (!selected) {
+        return { state, effects: [] };
+    }
+    const timeoutMs = selected.timeoutMs ?? state.options.defaultTimeoutMs;
+    const timeoutAt = state.options.timeoutEnabled && timeoutMs > 0 ? now + timeoutMs : undefined;
+    const nextFibers = { ...state.fibers };
+    for (const [id, fiber] of Object.entries(state.fibers)) {
+        if (id === selectedFiberId) {
+            nextFibers[id] = {
+                ...fiber,
+                status: 'running',
+                age: 0,
+                timeoutAt,
+                updatedAt: now,
+            };
+            continue;
+        }
+        if (fiber.status === 'ready') {
+            nextFibers[id] = {
+                ...fiber,
+                age: fiber.age + Math.max(0, state.options.agingStep),
+                updatedAt: now,
+            };
+        }
+    }
+    const effects = [];
+    const withStep = nextFibers[selectedFiberId];
+    if (withStep?.step) {
+        effects.push({
+            kind: 'send',
+            fiberId: selectedFiberId,
+            to: withStep.actorId,
+            step: withStep.step,
+        });
+    }
+    return {
+        state: {
+            ...state,
+            fibers: nextFibers,
+        },
+        effects,
+        selectedFiberId,
+    };
+}

package/dist-cjs/orchestration/types.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ORCHESTRATOR_OPTIONS = void 0;
+exports.DEFAULT_ORCHESTRATOR_OPTIONS = {
+    senderId: '__fiber_scheduler__',
+    agingStep: 1,
+    defaultSuspendPolicy: 'continue_others',
+    timeoutEnabled: false,
+    defaultTimeoutMs: 0,
+    retryEnabled: false,
+    retryDelayMs: 0,
+    retryBackoffMultiplier: 1,
+    deadLetterEnabled: false,
+};

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist-cjs/pipeline/ActorPipeline.cjs

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * depa-actor — ActorPipeline
+ *
+ * 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 (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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipelineHandler = createPipelineHandler;
+const depa_processor_1 = require("depa-processor");
+// ─── 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.
+ */
+function createPipelineHandler(pipeline) {
+    return async (self, envelope) => {
+        // `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 (0, depa_processor_1.runByFuncStyleAdapter)(self, envelope.payload, self.state, pipeline.computeDerived, pipeline.innerRuntime, pipeline.innerInput, pipeline.innerConfig, pipeline.coreLogic, pipeline.output);
+        await outputResult;
+    };
+}

package/dist-cjs/runtime/ActorRuntime.cjs

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * depa-actor — ActorRuntime
+ *
+ * Lifecycle and plugin layer over ActorSystem.
+ * ActorSystem = engine, ActorRuntime = managed environment.
+ *
+ * Future AiAgentVm will hold an ActorRuntime instance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActorRuntime = void 0;
+const ActorSystem_js_1 = require("../core/ActorSystem.cjs");
+// ─── ActorRuntime ────────────────────────────────────────────────────
+class ActorRuntime {
+    system;
+    plugins = [];
+    facets = new Map();
+    constructor(getRuntime, plugins) {
+        this.plugins = plugins ?? [];
+        this.system = new ActorSystem_js_1.ActorSystem(getRuntime, (entry) => this.handleLog(entry));
+    }
+    // ── Plugin management ──
+    addPlugin(plugin) {
+        this.plugins.push(plugin);
+    }
+    hasFacet(name) {
+        return this.facets.has(name);
+    }
+    getFacet(name) {
+        return this.facets.get(name);
+    }
+    setFacet(name, facet) {
+        this.facets.set(name, facet);
+        return facet;
+    }
+    ensureFacet(name, create) {
+        const existing = this.facets.get(name);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const created = create();
+        this.facets.set(name, created);
+        return created;
+    }
+    // ── Delegated API (convenience) ──
+    register(id, def) {
+        this.system.register(id, def);
+        for (const p of this.plugins) {
+            p.onRegister?.(id, def);
+        }
+    }
+    unregister(id) {
+        this.system.unregister(id);
+        for (const p of this.plugins) {
+            p.onUnregister?.(id);
+        }
+    }
+    sendFrom(from, to, tag, payload) {
+        this.system.sendFrom(from, to, tag, payload);
+    }
+    refFrom(from, to) {
+        return this.system.refFrom(from, to);
+    }
+    ids() {
+        return this.system.ids();
+    }
+    has(id) {
+        return this.system.has(id);
+    }
+    // ── Internal ──
+    handleLog(entry) {
+        for (const p of this.plugins) {
+            p.onLog?.(entry);
+        }
+    }
+}
+exports.ActorRuntime = ActorRuntime;

package/dist-cjs/runtime/completion.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionBindingRegistry = exports.CompletionSignalRegistry = void 0;
+exports.createCompletionSignalRegistry = createCompletionSignalRegistry;
+exports.createCompletionBindingRegistry = createCompletionBindingRegistry;
+class CompletionSignalRegistry {
+    waiters = new Map();
+    subscribe(key, waiter) {
+        const current = this.waiters.get(key) ?? new Set();
+        current.add(waiter);
+        this.waiters.set(key, current);
+        return () => {
+            const next = this.waiters.get(key);
+            if (!next) {
+                return;
+            }
+            next.delete(waiter);
+            if (next.size === 0) {
+                this.waiters.delete(key);
+            }
+        };
+    }
+    resolve(key, result) {
+        const waiters = this.waiters.get(key);
+        if (!waiters || waiters.size === 0) {
+            return;
+        }
+        this.waiters.delete(key);
+        for (const waiter of Array.from(waiters)) {
+            waiter(result);
+        }
+    }
+    has(key) {
+        return (this.waiters.get(key)?.size ?? 0) > 0;
+    }
+    count(key) {
+        return this.waiters.get(key)?.size ?? 0;
+    }
+    clear(key) {
+        if (key !== undefined) {
+            this.waiters.delete(key);
+            return;
+        }
+        this.waiters.clear();
+    }
+}
+exports.CompletionSignalRegistry = CompletionSignalRegistry;
+function createCompletionSignalRegistry() {
+    return new CompletionSignalRegistry();
+}
+class CompletionBindingRegistry {
+    bindings;
+    constructor(initial) {
+        this.bindings = Object.assign(Object.create(null), initial ?? {});
+    }
+    get(key) {
+        return this.bindings[key];
+    }
+    set(key, binding) {
+        this.bindings[key] = binding;
+    }
+    delete(key) {
+        delete this.bindings[key];
+    }
+    has(key) {
+        return key in this.bindings;
+    }
+    snapshot() {
+        return { ...this.bindings };
+    }
+}
+exports.CompletionBindingRegistry = CompletionBindingRegistry;
+function createCompletionBindingRegistry(initial) {
+    return new CompletionBindingRegistry(initial);
+}

package/dist-cjs/runtime/indexing.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeIndexHook = void 0;
+exports.createRuntimeIndexHook = createRuntimeIndexHook;
+class RuntimeIndexHook {
+    entries = new Map();
+    constructor(initial) {
+        for (const [key, value] of Object.entries(initial ?? {})) {
+            this.entries.set(key, value);
+        }
+    }
+    get(key) {
+        return this.entries.get(key);
+    }
+    set(key, value) {
+        this.entries.set(key, value);
+    }
+    delete(key) {
+        this.entries.delete(key);
+    }
+    has(key) {
+        return this.entries.has(key);
+    }
+    values() {
+        return Array.from(this.entries.values());
+    }
+    snapshot() {
+        return Object.fromEntries(this.entries.entries());
+    }
+}
+exports.RuntimeIndexHook = RuntimeIndexHook;
+function createRuntimeIndexHook(initial) {
+    return new RuntimeIndexHook(initial);
+}

package/dist-cjs/runtime/snapshot.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSnapshotCodec = createSnapshotCodec;
+exports.createRecoveryHooks = createRecoveryHooks;
+exports.createPersistenceEffectPort = createPersistenceEffectPort;
+function createSnapshotCodec(codec) {
+    return codec;
+}
+function createRecoveryHooks(hooks) {
+    return hooks;
+}
+function createPersistenceEffectPort(port) {
+    return port;
+}

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "depa-actor",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist-cjs/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist-cjs/index.cjs"
     }
   },
   "files": [
     "dist",
+    "dist-cjs",
     "src"
   ],
+  "dependencies": {
+    "depa-processor": "0.1.1"
+  },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.cjs.json && node scripts/build-cjs.mjs",
     "dev": "tsc --watch",
     "test": "bun test",
     "test:watch": "bun test --watch"