@fiducian/conductor 0.4.0

package/dist/actorchestra.d.ts

@@ -0,0 +1,15 @@
+import type { StoryContext } from "./types.js";
+/**
+ * ACTORCHESTRA — propagate Fiducia story context across fetch calls automatically.
+ */
+export declare class Actorchestra {
+    private active?;
+    /** Run a block with an active story context (used by fetch wrapper). */
+    runWithContext<T>(ctx: StoryContext, fn: () => T): T;
+    getActiveContext(): StoryContext | undefined;
+    /** Inject X-Fiducia-Context on outbound fetch when a context is active. */
+    wrapFetch(baseFetch?: typeof fetch): typeof fetch;
+    /** Merge context header into plain header objects (Express/Node handlers). */
+    injectHeaders(ctx: StoryContext, headers?: Record<string, string>): Record<string, string>;
+}
+export declare const actorchestra: Actorchestra;

package/dist/actorchestra.js

@@ -0,0 +1,37 @@
+import { CONTEXT_HEADER, headerFromContext } from "./types.js";
+/**
+ * ACTORCHESTRA — propagate Fiducia story context across fetch calls automatically.
+ */
+export class Actorchestra {
+    active;
+    /** Run a block with an active story context (used by fetch wrapper). */
+    runWithContext(ctx, fn) {
+        const prev = this.active;
+        this.active = ctx;
+        try {
+            return fn();
+        }
+        finally {
+            this.active = prev;
+        }
+    }
+    getActiveContext() {
+        return this.active;
+    }
+    /** Inject X-Fiducia-Context on outbound fetch when a context is active. */
+    wrapFetch(baseFetch = globalThis.fetch) {
+        const self = this;
+        return async (input, init) => {
+            const headers = new Headers(init?.headers);
+            if (self.active) {
+                headers.set(CONTEXT_HEADER, headerFromContext(self.active));
+            }
+            return baseFetch(input, { ...init, headers });
+        };
+    }
+    /** Merge context header into plain header objects (Express/Node handlers). */
+    injectHeaders(ctx, headers = {}) {
+        return { ...headers, [CONTEXT_HEADER]: headerFromContext(ctx) };
+    }
+}
+export const actorchestra = new Actorchestra();

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { ContextId, StoryContext, TraceEvent } from "./types.js";
+export type { ContextId, StoryContext, TraceEvent, Violation, Verdict } from "./types.js";
+export { CONTEXT_HEADER, contextFromHeader, headerFromContext } from "./types.js";
+export { Actorchestra, actorchestra } from "./actorchestra.js";
+export type EventListener = (event: TraceEvent) => void;
+export declare class Conductor {
+    private listeners;
+    private events;
+    startStory(parentContext?: ContextId): StoryContext;
+    startStoryWithId(contextId: ContextId, parentContext?: ContextId): StoryContext;
+    emit(ctx: StoryContext, message: Omit<TraceEvent, "contextId" | "timestamp">): TraceEvent;
+    subscribe(listener: EventListener): () => void;
+    getEvents(): readonly TraceEvent[];
+    getEventsForContext(contextId: ContextId): TraceEvent[];
+    clear(): void;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+import { randomUUID } from "node:crypto";
+export { CONTEXT_HEADER, contextFromHeader, headerFromContext } from "./types.js";
+export { Actorchestra, actorchestra } from "./actorchestra.js";
+export class Conductor {
+    listeners = new Set();
+    events = [];
+    startStory(parentContext) {
+        return this.startStoryWithId(randomUUID(), parentContext);
+    }
+    startStoryWithId(contextId, parentContext) {
+        return {
+            contextId,
+            parentContext,
+        };
+    }
+    emit(ctx, message) {
+        const event = {
+            contextId: ctx.contextId,
+            timestamp: Date.now(),
+            ...message,
+        };
+        this.events.push(event);
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+        return event;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getEvents() {
+        return this.events;
+    }
+    getEventsForContext(contextId) {
+        return this.events.filter((e) => e.contextId === contextId);
+    }
+    clear() {
+        this.events = [];
+    }
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Conductor } from "./index.js";
+test("Conductor assigns context and emits events", () => {
+    const conductor = new Conductor();
+    const seen = [];
+    conductor.subscribe((e) => seen.push(`${e.from}->${e.to}:${e.op}`));
+    const ctx = conductor.startStory();
+    conductor.emit(ctx, {
+        from: "client",
+        to: "order",
+        op: "place",
+        payload: { orderId: "1" },
+    });
+    assert.equal(seen.length, 1);
+    assert.equal(conductor.getEventsForContext(ctx.contextId).length, 1);
+});

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+export type ContextId = string;
+export declare const CONTEXT_HEADER = "x-fiducia-context";
+export interface StoryContext {
+    contextId: ContextId;
+    parentContext?: ContextId;
+}
+export declare function headerFromContext(ctx: StoryContext): string;
+export declare function contextFromHeader(header: string | undefined): StoryContext | undefined;
+export interface TraceEvent {
+    contextId: ContextId;
+    from: string;
+    to: string;
+    op: string;
+    payload: Record<string, unknown>;
+    timestamp: number;
+}
+export type Verdict = "pass" | "violated" | "inconclusive";
+export interface Violation {
+    contextId: ContextId;
+    message: string;
+    step?: number;
+    event?: TraceEvent;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+export const CONTEXT_HEADER = "x-fiducia-context";
+export function headerFromContext(ctx) {
+    return ctx.contextId;
+}
+export function contextFromHeader(header) {
+    if (!header)
+        return undefined;
+    return { contextId: header };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@fiducian/conductor",
+  "version": "0.4.0",
+  "description": "Story context IDs and event bus for FiduciaTrace causal chain checking",
+  "license": "AGPL-3.0-or-later",
+  "keywords": ["fiducia", "fiducia", "causal", "distributed-systems", "context"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thesnmc/Fiducian.git",
+    "directory": "trace/packages/conductor"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["dist"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/**/*.test.js",
+    "prepublishOnly": "npm run build"
+  }
+}