@kronos-ts/messaging 0.1.0

package/dist/retrying-command-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrying-command-bus.js","sourceRoot":"","sources":["../src/retrying-command-bus.ts"],"names":[],"mappings":"AAeA;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAI7C;IACC,MAAM,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,CAAC,CAAA;IAC3C,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,IAAI,EAAE,CAAA;IACpD,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,kBAAkB,CAAA;IAE9D,OAAO;QACL,WAAW,CAAC,KAAc,EAAE,OAAe;YACzC,IAAI,OAAO,IAAI,UAAU;gBAAE,OAAO,SAAS,CAAA;YAC3C,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;gBAAE,OAAO,SAAS,CAAA;YACzC,OAAO,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;QAC9C,CAAC;KACF,CAAA;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc;IACxC,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,IAAI,KAAK,sBAAsB,CAAA;IAC9C,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAAoB,EACpB,MAAmB;IAEnB,OAAO;QACL,KAAK,CAAC,QAAQ,CAAC,OAAuB;YACpC,IAAI,OAAO,GAAG,CAAC,CAAA;YACf,OAAO,IAAI,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,OAAO,MAAM,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;gBACzC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;oBAChD,IAAI,KAAK,KAAK,SAAS;wBAAE,MAAM,KAAK,CAAA;oBAEpC,OAAO,EAAE,CAAA;oBACT,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;wBACd,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAA;oBAC5D,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,SAAS,CAAC,WAAmB,EAAE,OAAsD;YACnF,QAAQ,CAAC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;QAC1C,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/routing-strategy.d.ts

@@ -0,0 +1,30 @@
+import type { CommandMessage } from "./message.js";
+/**
+ * Determines the routing key for a command message.
+ *
+ * Used by the distributed command bus to route commands to the correct
+ * handler instance via consistent hashing. Commands with the same routing
+ * key are routed to the same handler.
+ */
+export interface RoutingStrategy {
+    /**
+     * Get the routing key for the given command message.
+     * Returns a string that identifies the target for this command
+     * (typically an aggregate identifier).
+     */
+    getRoutingKey(message: CommandMessage): string;
+}
+/**
+ * Extracts the routing key from a command message's metadata.
+ *
+ * @param metadataKey The metadata key to extract the routing key from.
+ */
+export declare function metadataRoutingStrategy(metadataKey: string): RoutingStrategy;
+/**
+ * Extracts the routing key from a field of the command payload.
+ * The field name is specified explicitly on the descriptor/configuration.
+ *
+ * @param field The payload field to extract the routing key from.
+ */
+export declare function payloadFieldRoutingStrategy(field: string): RoutingStrategy;
+//# sourceMappingURL=routing-strategy.d.ts.map

package/dist/routing-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-strategy.d.ts","sourceRoot":"","sources":["../src/routing-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAAA;CAC/C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,CAa5E;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAc1E"}

package/dist/routing-strategy.js

@@ -0,0 +1,37 @@
+/**
+ * Extracts the routing key from a command message's metadata.
+ *
+ * @param metadataKey The metadata key to extract the routing key from.
+ */
+export function metadataRoutingStrategy(metadataKey) {
+    return {
+        getRoutingKey(message) {
+            const value = message.metadata[metadataKey];
+            if (value == null) {
+                throw new Error(`No routing key found in metadata key "${metadataKey}" ` +
+                    `for command "${String(message.name)}"`);
+            }
+            return String(value);
+        },
+    };
+}
+/**
+ * Extracts the routing key from a field of the command payload.
+ * The field name is specified explicitly on the descriptor/configuration.
+ *
+ * @param field The payload field to extract the routing key from.
+ */
+export function payloadFieldRoutingStrategy(field) {
+    return {
+        getRoutingKey(message) {
+            const payload = message.payload;
+            const value = payload?.[field];
+            if (value == null) {
+                throw new Error(`No routing key found in payload field "${field}" ` +
+                    `for command "${String(message.name)}"`);
+            }
+            return String(value);
+        },
+    };
+}
+//# sourceMappingURL=routing-strategy.js.map

package/dist/routing-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-strategy.js","sourceRoot":"","sources":["../src/routing-strategy.ts"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAmB;IACzD,OAAO;QACL,aAAa,CAAC,OAAuB;YACnC,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAA;YAC3C,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CACb,yCAAyC,WAAW,IAAI;oBACxD,gBAAgB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACxC,CAAA;YACH,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;QACtB,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CAAC,KAAa;IACvD,OAAO;QACL,aAAa,CAAC,OAAuB;YACnC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAkC,CAAA;YAC1D,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC,KAAK,CAAC,CAAA;YAC9B,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CACb,0CAA0C,KAAK,IAAI;oBACnD,gBAAgB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CACxC,CAAA;YACH,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;QACtB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/segment.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Represents a fraction of the event stream assigned to a processor instance.
+ *
+ * Segments use bitmask-based routing to deterministically assign events
+ * to processors. An event matches a segment when `(hash(event) & mask) === segmentId`.
+ *
+ * Segments can be split (doubling parallelism) and merged (halving parallelism).
+ * This is the foundation for horizontal scaling — multiple instances of the
+ * same processor each claim different segments.
+ *
+ * The ROOT_SEGMENT (segmentId=0, mask=0) matches ALL events and is the
+ * starting point before any splitting.
+ */
+export interface Segment {
+    /** The unique identifier of this segment. */
+    readonly segmentId: number;
+    /**
+     * The bitmask used to match events to this segment.
+     * An event matches when `(hash & mask) === segmentId`.
+     */
+    readonly mask: number;
+}
+/** The root segment — matches all events. Starting point before splitting. */
+export declare const ROOT_SEGMENT: Segment;
+/**
+ * Create a segment with the given id and mask.
+ */
+export declare function segment(segmentId: number, mask: number): Segment;
+/**
+ * Check if a hash value matches this segment.
+ * Used to route events to the correct processor instance.
+ *
+ * @param seg The segment to check against
+ * @param hash The hash of the event's sequence identifier (e.g., aggregate ID hash)
+ */
+export declare function segmentMatches(seg: Segment, hash: number): boolean;
+/**
+ * Split a segment into two child segments.
+ * Doubles the processing parallelism for this segment's portion of the stream.
+ *
+ * Returns a tuple of [segment keeping the original ID, new sibling segment].
+ */
+export declare function splitSegment(seg: Segment): [Segment, Segment];
+/**
+ * Check if two segments can be merged (they are siblings from the same split).
+ */
+export declare function isMergeable(a: Segment, b: Segment): boolean;
+/**
+ * Merge two sibling segments back into their parent.
+ * Halves the processing parallelism.
+ *
+ * @throws Error if segments are not mergeable
+ */
+export declare function mergeSegments(a: Segment, b: Segment): Segment;
+/**
+ * Compute the total number of segments at the current split level.
+ * For a segment with mask M, the total count is M + 1.
+ */
+export declare function segmentCount(seg: Segment): number;
+/**
+ * Compute a hash from a string value (for event routing).
+ * Uses a simple but well-distributed hash function.
+ */
+export declare function hashOf(value: string): number;
+/**
+ * Create N balanced segments by splitting the root segment.
+ *
+ * @param count Number of segments (must be a power of 2)
+ * @returns Array of segments that together cover the entire event stream
+ */
+export declare function createSegments(count: number): Segment[];
+//# sourceMappingURL=segment.d.ts.map

package/dist/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../src/segment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,OAAO;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,8EAA8E;AAC9E,eAAO,MAAM,YAAY,EAAE,OAAmC,CAAA;AAE9D;;GAEG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAQ7D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAK3D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAW7D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO5C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,CAmBvD"}

package/dist/segment.js

@@ -0,0 +1,103 @@
+/** The root segment — matches all events. Starting point before splitting. */
+export const ROOT_SEGMENT = { segmentId: 0, mask: 0 };
+/**
+ * Create a segment with the given id and mask.
+ */
+export function segment(segmentId, mask) {
+    return { segmentId, mask };
+}
+/**
+ * Check if a hash value matches this segment.
+ * Used to route events to the correct processor instance.
+ *
+ * @param seg The segment to check against
+ * @param hash The hash of the event's sequence identifier (e.g., aggregate ID hash)
+ */
+export function segmentMatches(seg, hash) {
+    return (hash & seg.mask) === seg.segmentId;
+}
+/**
+ * Split a segment into two child segments.
+ * Doubles the processing parallelism for this segment's portion of the stream.
+ *
+ * Returns a tuple of [segment keeping the original ID, new sibling segment].
+ */
+export function splitSegment(seg) {
+    const newMask = (seg.mask << 1) | 1;
+    const newSegmentId = seg.segmentId | (seg.mask + 1);
+    return [
+        { segmentId: seg.segmentId, mask: newMask },
+        { segmentId: newSegmentId, mask: newMask },
+    ];
+}
+/**
+ * Check if two segments can be merged (they are siblings from the same split).
+ */
+export function isMergeable(a, b) {
+    if (a.mask !== b.mask)
+        return false;
+    if (a.mask === 0)
+        return false;
+    // Siblings differ only in the highest bit of the mask
+    return (a.segmentId ^ b.segmentId) === (a.mask >>> 0) - (a.mask >>> 1);
+}
+/**
+ * Merge two sibling segments back into their parent.
+ * Halves the processing parallelism.
+ *
+ * @throws Error if segments are not mergeable
+ */
+export function mergeSegments(a, b) {
+    if (!isMergeable(a, b)) {
+        throw new Error(`Segments ${a.segmentId}/${a.mask} and ${b.segmentId}/${b.mask} are not mergeable`);
+    }
+    return {
+        segmentId: Math.min(a.segmentId, b.segmentId),
+        mask: a.mask >>> 1,
+    };
+}
+/**
+ * Compute the total number of segments at the current split level.
+ * For a segment with mask M, the total count is M + 1.
+ */
+export function segmentCount(seg) {
+    return seg.mask + 1;
+}
+/**
+ * Compute a hash from a string value (for event routing).
+ * Uses a simple but well-distributed hash function.
+ */
+export function hashOf(value) {
+    let hash = 0;
+    for (let i = 0; i < value.length; i++) {
+        const char = value.charCodeAt(i);
+        hash = ((hash << 5) - hash + char) | 0;
+    }
+    return hash >>> 0; // Ensure unsigned
+}
+/**
+ * Create N balanced segments by splitting the root segment.
+ *
+ * @param count Number of segments (must be a power of 2)
+ * @returns Array of segments that together cover the entire event stream
+ */
+export function createSegments(count) {
+    if (count <= 0)
+        throw new Error("Segment count must be positive");
+    if (count === 1)
+        return [ROOT_SEGMENT];
+    // Find the nearest power of 2
+    const power = Math.ceil(Math.log2(count));
+    const actualCount = Math.pow(2, power);
+    let segments = [ROOT_SEGMENT];
+    while (segments.length < actualCount) {
+        const next = [];
+        for (const seg of segments) {
+            const [a, b] = splitSegment(seg);
+            next.push(a, b);
+        }
+        segments = next;
+    }
+    return segments;
+}
+//# sourceMappingURL=segment.js.map

package/dist/segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.js","sourceRoot":"","sources":["../src/segment.ts"],"names":[],"mappings":"AAuBA,8EAA8E;AAC9E,MAAM,CAAC,MAAM,YAAY,GAAY,EAAE,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAA;AAE9D;;GAEG;AACH,MAAM,UAAU,OAAO,CAAC,SAAiB,EAAE,IAAY;IACrD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAA;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,GAAY,EAAE,IAAY;IACvD,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,SAAS,CAAA;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACnC,MAAM,YAAY,GAAG,GAAG,CAAC,SAAS,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAA;IAEnD,OAAO;QACL,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE;QAC3C,EAAE,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE;KAC3C,CAAA;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,CAAU,EAAE,CAAU;IAChD,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI;QAAE,OAAO,KAAK,CAAA;IACnC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IAC9B,sDAAsD;IACtD,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAA;AACxE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,CAAU,EAAE,CAAU;IAClD,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CACb,YAAY,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,IAAI,oBAAoB,CACnF,CAAA;IACH,CAAC;IAED,OAAO;QACL,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC;QAC7C,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,CAAC;KACnB,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,OAAO,GAAG,CAAC,IAAI,GAAG,CAAC,CAAA;AACrB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAC,KAAa;IAClC,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QAChC,IAAI,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;IACxC,CAAC;IACD,OAAO,IAAI,KAAK,CAAC,CAAA,CAAC,kBAAkB;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,KAAK,IAAI,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;IACjE,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,CAAC,YAAY,CAAC,CAAA;IAEtC,8BAA8B;IAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IACzC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;IAEtC,IAAI,QAAQ,GAAc,CAAC,YAAY,CAAC,CAAA;IACxC,OAAO,QAAQ,CAAC,MAAM,GAAG,WAAW,EAAE,CAAC;QACrC,MAAM,IAAI,GAAc,EAAE,CAAA;QAC1B,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;YAChC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QACjB,CAAC;QACD,QAAQ,GAAG,IAAI,CAAA;IACjB,CAAC;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC"}

package/dist/send.d.ts

@@ -0,0 +1,28 @@
+import { type ResourceKey } from "@kronos-ts/common";
+import type { CommandBus } from "./command-bus.js";
+import type { CommandDescriptor } from "./descriptor.js";
+import type { z } from "zod";
+type CommandDispatchFunction = <P extends z.ZodType, R extends z.ZodType | undefined = undefined>(descriptor: CommandDescriptor<P, R>, payload: z.infer<P>) => Promise<unknown>;
+/**
+ * Resource key for the command bus component.
+ * Written by handling modules + processors at handler-invocation entry (D-44).
+ */
+export declare const COMMAND_BUS_KEY: ResourceKey<CommandBus>;
+/**
+ * Send a command from inside a handler.
+ *
+ * AF5-aligned semantics: every command is handled in its own fresh
+ * UnitOfWork (`commandBus.dispatch` always starts a new one — see
+ * `createSimpleCommandBus`). The command handler is therefore its own
+ * atomic boundary: it loads state, decides, appends events, and commits
+ * once — independent of the caller's UnitOfWork.
+ *
+ * The caller's `metadata` IS carried onto the outgoing command, so
+ * correlation/causation lineage propagates the AF5 way — through message
+ * metadata, applied by the correlation-data dispatch interceptor — across
+ * any transport, local or distributed. No processing-context object is
+ * threaded through the command API or over the wire.
+ */
+export declare const send: CommandDispatchFunction;
+export {};
+//# sourceMappingURL=send.d.ts.map

package/dist/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAErF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,KAAK,uBAAuB,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,SAAS,GAAG,SAAS,EAC9F,UAAU,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,EACnC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAChB,OAAO,CAAC,OAAO,CAAC,CAAA;AAErB;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,UAAU,CAA6B,CAAA;AAEjF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,EAAE,uBAWlB,CAAA"}

package/dist/send.js

@@ -0,0 +1,36 @@
+import { resourceKey, generateIdentifier } from "@kronos-ts/common";
+import { requireInvocationPhase } from "./processing-state.js";
+/**
+ * Resource key for the command bus component.
+ * Written by handling modules + processors at handler-invocation entry (D-44).
+ */
+export const COMMAND_BUS_KEY = resourceKey("commandBus");
+/**
+ * Send a command from inside a handler.
+ *
+ * AF5-aligned semantics: every command is handled in its own fresh
+ * UnitOfWork (`commandBus.dispatch` always starts a new one — see
+ * `createSimpleCommandBus`). The command handler is therefore its own
+ * atomic boundary: it loads state, decides, appends events, and commits
+ * once — independent of the caller's UnitOfWork.
+ *
+ * The caller's `metadata` IS carried onto the outgoing command, so
+ * correlation/causation lineage propagates the AF5 way — through message
+ * metadata, applied by the correlation-data dispatch interceptor — across
+ * any transport, local or distributed. No processing-context object is
+ * threaded through the command API or over the wire.
+ */
+export const send = async (descriptor, payload) => {
+    const state = requireInvocationPhase(); // D-43 mutator guard
+    const bus = state.resources.get(COMMAND_BUS_KEY.symbol);
+    if (!bus)
+        throw new Error("No command bus configured");
+    return bus.dispatch({
+        identifier: generateIdentifier(),
+        name: descriptor.name,
+        payload,
+        metadata: state.metadata,
+        timestamp: Date.now(),
+    });
+};
+//# sourceMappingURL=send.js.map

package/dist/send.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.js","sourceRoot":"","sources":["../src/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAoB,MAAM,mBAAmB,CAAA;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAU9D;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAA4B,WAAW,CAAC,YAAY,CAAC,CAAA;AAEjF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,IAAI,GAA4B,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE;IACzE,MAAM,KAAK,GAAG,sBAAsB,EAAE,CAAA,CAAC,qBAAqB;IAC5D,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAA2B,CAAA;IACjF,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;IACtD,OAAO,GAAG,CAAC,QAAQ,CAAC;QAClB,UAAU,EAAE,kBAAkB,EAAE;QAChC,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,OAAO;QACP,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/serializer.d.ts

@@ -0,0 +1,40 @@
+import type { Serializer } from "@kronos-ts/common";
+import type { z } from "zod";
+/**
+ * JSON serializer — the default serializer for the TypeScript framework.
+ *
+ * Serializes values as JSON-encoded Uint8Array. Handles `undefined`,
+ * `null`, and all JSON-compatible values.
+ */
+export declare function jsonSerializer(): Serializer;
+/**
+ * A registry of Zod schemas indexed by type name + revision.
+ * Used by the validating serializer decorator to validate
+ * deserialized payloads against their expected schema.
+ */
+export interface SchemaRegistry {
+    register(typeName: string, revision: string, schema: z.ZodType): void;
+    get(typeName: string, revision: string): z.ZodType | undefined;
+}
+/** Schema registry for event payloads. */
+export declare function createEventSchemaRegistry(): SchemaRegistry;
+/** Schema registry for command payloads. */
+export declare function createCommandSchemaRegistry(): SchemaRegistry;
+/** Schema registry for query payloads. */
+export declare function createQuerySchemaRegistry(): SchemaRegistry;
+/**
+ * Wraps a delegate serializer with Zod validation on deserialization.
+ *
+ * When deserializing, looks up the schema in the registry by type name
+ * and revision. If found, validates the deserialized value against it.
+ * If not found, passes through without validation.
+ *
+ * ```typescript
+ * const serializer = zodValidatingSerializer(
+ *   jsonSerializer(),
+ *   mySchemaRegistry,
+ * )
+ * ```
+ */
+export declare function zodValidatingSerializer(delegate: Serializer, schemaRegistry: SchemaRegistry): Serializer;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,mBAAmB,CAAA;AACrE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAK5B;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,UAAU,CAmB3C;AAMD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAA;IACrE,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,GAAG,SAAS,CAAA;CAC/D;AAED,0CAA0C;AAC1C,wBAAgB,yBAAyB,IAAI,cAAc,CAE1D;AAED,4CAA4C;AAC5C,wBAAgB,2BAA2B,IAAI,cAAc,CAE5D;AAED,0CAA0C;AAC1C,wBAAgB,yBAAyB,IAAI,cAAc,CAE1D;AAyBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,UAAU,EACpB,cAAc,EAAE,cAAc,GAC7B,UAAU,CAmBZ"}

package/dist/serializer.js

@@ -0,0 +1,90 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * JSON serializer — the default serializer for the TypeScript framework.
+ *
+ * Serializes values as JSON-encoded Uint8Array. Handles `undefined`,
+ * `null`, and all JSON-compatible values.
+ */
+export function jsonSerializer() {
+    return {
+        serialize(value, type, revision = "") {
+            return {
+                type,
+                revision,
+                data: encoder.encode(JSON.stringify(value)),
+            };
+        },
+        deserialize(data) {
+            if (data.data.length === 0)
+                return undefined;
+            return JSON.parse(decoder.decode(data.data));
+        },
+        canConvert() {
+            return true;
+        },
+    };
+}
+/** Schema registry for event payloads. */
+export function createEventSchemaRegistry() {
+    return createSchemaRegistry();
+}
+/** Schema registry for command payloads. */
+export function createCommandSchemaRegistry() {
+    return createSchemaRegistry();
+}
+/** Schema registry for query payloads. */
+export function createQuerySchemaRegistry() {
+    return createSchemaRegistry();
+}
+function createSchemaRegistry() {
+    const schemas = new Map();
+    function key(typeName, revision) {
+        return `${typeName}@${revision}`;
+    }
+    return {
+        register(typeName, revision, schema) {
+            schemas.set(key(typeName, revision), schema);
+        },
+        get(typeName, revision) {
+            // Try exact match first, then fallback to no revision
+            return schemas.get(key(typeName, revision)) ?? schemas.get(key(typeName, ""));
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Zod-validating serializer decorator
+// ---------------------------------------------------------------------------
+/**
+ * Wraps a delegate serializer with Zod validation on deserialization.
+ *
+ * When deserializing, looks up the schema in the registry by type name
+ * and revision. If found, validates the deserialized value against it.
+ * If not found, passes through without validation.
+ *
+ * ```typescript
+ * const serializer = zodValidatingSerializer(
+ *   jsonSerializer(),
+ *   mySchemaRegistry,
+ * )
+ * ```
+ */
+export function zodValidatingSerializer(delegate, schemaRegistry) {
+    return {
+        serialize(value, type, revision) {
+            return delegate.serialize(value, type, revision);
+        },
+        deserialize(data) {
+            const raw = delegate.deserialize(data);
+            const schema = schemaRegistry.get(data.type, data.revision);
+            if (schema) {
+                return schema.parse(raw);
+            }
+            return raw;
+        },
+        canConvert(type) {
+            return delegate.canConvert(type);
+        },
+    };
+}
+//# sourceMappingURL=serializer.js.map

package/dist/serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../src/serializer.ts"],"names":[],"mappings":"AAGA,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;AACjC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;AAEjC;;;;;GAKG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO;QACL,SAAS,CAAC,KAAc,EAAE,IAAY,EAAE,WAAmB,EAAE;YAC3D,OAAO;gBACL,IAAI;gBACJ,QAAQ;gBACR,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;aAC5C,CAAA;QACH,CAAC;QAED,WAAW,CAAI,IAAsB;YACnC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,SAAc,CAAA;YACjD,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAM,CAAA;QACnD,CAAC;QAED,UAAU;YACR,OAAO,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC;AAgBD,0CAA0C;AAC1C,MAAM,UAAU,yBAAyB;IACvC,OAAO,oBAAoB,EAAE,CAAA;AAC/B,CAAC;AAED,4CAA4C;AAC5C,MAAM,UAAU,2BAA2B;IACzC,OAAO,oBAAoB,EAAE,CAAA;AAC/B,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,yBAAyB;IACvC,OAAO,oBAAoB,EAAE,CAAA;AAC/B,CAAC;AAED,SAAS,oBAAoB;IAC3B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAqB,CAAA;IAE5C,SAAS,GAAG,CAAC,QAAgB,EAAE,QAAgB;QAC7C,OAAO,GAAG,QAAQ,IAAI,QAAQ,EAAE,CAAA;IAClC,CAAC;IAED,OAAO;QACL,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM;YACjC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAA;QAC9C,CAAC;QAED,GAAG,CAAC,QAAQ,EAAE,QAAQ;YACpB,sDAAsD;YACtD,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAA;QAC/E,CAAC;KACF,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,sCAAsC;AACtC,8EAA8E;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,uBAAuB,CACrC,QAAoB,EACpB,cAA8B;IAE9B,OAAO;QACL,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ;YAC7B,OAAO,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;QAClD,CAAC;QAED,WAAW,CAAI,IAAsB;YACnC,MAAM,GAAG,GAAG,QAAQ,CAAC,WAAW,CAAU,IAAI,CAAC,CAAA;YAC/C,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC3D,IAAI,MAAM,EAAE,CAAC;gBACX,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,CAAM,CAAA;YAC/B,CAAC;YACD,OAAO,GAAQ,CAAA;QACjB,CAAC;QAED,UAAU,CAAC,IAAI;YACb,OAAO,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QAClC,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/simple-command-bus.d.ts

@@ -0,0 +1,23 @@
+import type { CommandBus } from "./command-bus.js";
+/**
+ * Simple in-process command bus.
+ *
+ * Maintains a local handler map and dispatches commands directly,
+ * wrapping each dispatch in a fresh UnitOfWork via `runInNewUoW`.
+ *
+ * AF5 parity: like `SimpleCommandBus`, every command — primary OR nested
+ * (dispatched from inside another handler via `send()`) — is handled in
+ * its own independent UnitOfWork with its own commit boundary. A command
+ * handler is the atomic unit; commands compose by independent commit, not
+ * by sharing a transaction. DCB read-set / append-condition merging
+ * happens only WITHIN a single handler's UnitOfWork.
+ *
+ * Transactional wiring composes at the runner level via
+ * `transactionalUnitOfWorkFactory(runInNewUoW, txManager)` and is consumed
+ * by extensions / processors directly, not by the bus.
+ *
+ * Interceptor support is provided by wrapping with
+ * {@link createInterceptingCommandBus}.
+ */
+export declare function createSimpleCommandBus(): CommandBus;
+//# sourceMappingURL=simple-command-bus.d.ts.map

package/dist/simple-command-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-command-bus.d.ts","sourceRoot":"","sources":["../src/simple-command-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAKlD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,IAAI,UAAU,CAiCnD"}

package/dist/simple-command-bus.js

@@ -0,0 +1,49 @@
+import { runInNewUoW } from "./unit-of-work.js";
+import { qualifiedNameToString } from "@kronos-ts/common";
+/**
+ * Simple in-process command bus.
+ *
+ * Maintains a local handler map and dispatches commands directly,
+ * wrapping each dispatch in a fresh UnitOfWork via `runInNewUoW`.
+ *
+ * AF5 parity: like `SimpleCommandBus`, every command — primary OR nested
+ * (dispatched from inside another handler via `send()`) — is handled in
+ * its own independent UnitOfWork with its own commit boundary. A command
+ * handler is the atomic unit; commands compose by independent commit, not
+ * by sharing a transaction. DCB read-set / append-condition merging
+ * happens only WITHIN a single handler's UnitOfWork.
+ *
+ * Transactional wiring composes at the runner level via
+ * `transactionalUnitOfWorkFactory(runInNewUoW, txManager)` and is consumed
+ * by extensions / processors directly, not by the bus.
+ *
+ * Interceptor support is provided by wrapping with
+ * {@link createInterceptingCommandBus}.
+ */
+export function createSimpleCommandBus() {
+    const handlers = new Map();
+    return {
+        async dispatch(message) {
+            const key = qualifiedNameToString(message.name);
+            const handler = handlers.get(key);
+            if (!handler) {
+                throw new Error(`No handler registered for command "${key}"`);
+            }
+            // AF5 parity: every command gets its own fresh UnitOfWork, even when
+            // dispatched from inside another handler. Dispatch interceptors have
+            // already run in the caller's context (the intercepting bus wraps
+            // this one), so correlation data is carried on `message.metadata`
+            // before we cross into the new UoW.
+            return runInNewUoW(message.metadata, () => handler(message));
+        },
+        subscribe(commandName, handler) {
+            const existing = handlers.get(commandName);
+            if (existing && existing !== handler) {
+                throw new Error(`A different handler is already registered for command "${commandName}". ` +
+                    `Duplicate command handler subscriptions are not allowed.`);
+            }
+            handlers.set(commandName, handler);
+        },
+    };
+}
+//# sourceMappingURL=simple-command-bus.js.map

package/dist/simple-command-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-command-bus.js","sourceRoot":"","sources":["../src/simple-command-bus.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,sBAAsB;IACpC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAyD,CAAA;IAEjF,OAAO;QACL,KAAK,CAAC,QAAQ,CAAC,OAAuB;YACpC,MAAM,GAAG,GAAG,qBAAqB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAC/C,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YACjC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,sCAAsC,GAAG,GAAG,CAAC,CAAA;YAC/D,CAAC;YAED,qEAAqE;YACrE,qEAAqE;YACrE,kEAAkE;YAClE,kEAAkE;YAClE,oCAAoC;YACpC,OAAO,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;QAC9D,CAAC;QAED,SAAS,CACP,WAAmB,EACnB,OAAsD;YAEtD,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;YAC1C,IAAI,QAAQ,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;gBACrC,MAAM,IAAI,KAAK,CACb,0DAA0D,WAAW,KAAK;oBAC1E,0DAA0D,CAC3D,CAAA;YACH,CAAC;YACD,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;QACpC,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/simple-query-bus.d.ts

@@ -0,0 +1,16 @@
+import type { QueryBus } from "./query-bus.js";
+/**
+ * Simple in-process query bus with subscription query support.
+ *
+ * Direct queries are dispatched within a UnitOfWork via `runInUoW`.
+ * Subscription queries receive an initial result plus a stream of
+ * incremental updates emitted via `emitUpdate()`.
+ *
+ * Plan 03-04 (CTX-04 / D-34): the explicit `unitOfWorkFactory`
+ * parameter and branch are gone. `runInUoW` is the only codepath.
+ *
+ * Interceptor support is provided by wrapping with
+ * {@link createInterceptingQueryBus}.
+ */
+export declare function createSimpleQueryBus(): QueryBus;
+//# sourceMappingURL=simple-query-bus.d.ts.map

package/dist/simple-query-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-query-bus.d.ts","sourceRoot":"","sources":["../src/simple-query-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAO9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,QAAQ,CAyI/C"}