@zlink-systems/framework 0.10.0

package/dist/contracts/Configuration/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Connections"), exports);
+__exportStar(require("./ObjectRoles"), exports);

package/dist/contracts/Dispatch/ZLinkDispatchOptions.d.ts

@@ -0,0 +1,181 @@
+import type { ZLinkFlowOrigin } from './ZLinkFlowOrigin';
+export declare enum ZLinkCoreHwmProfile {
+    Compact = "compact",
+    LowLatency = "low_latency",
+    Balanced = "balanced",
+    Throughput = "throughput"
+}
+export declare enum ZLinkApplicationJobQueueProfile {
+    Compact = "compact",
+    LowLatency = "low_latency",
+    Balanced = "balanced",
+    Throughput = "throughput"
+}
+export interface ZLinkInboundDispatchOptions {
+    coreHwmMemoryLimitBytes(value: bigint | undefined): this;
+    coreHwmBudgetBytes(value: bigint | undefined): this;
+    coreHwmProfile(value: ZLinkCoreHwmProfile): this;
+    applicationJobQueueProfile(value: ZLinkApplicationJobQueueProfile): this;
+    maxQueuedApplicationJobs(value: bigint | undefined): this;
+    applicationJobQueuePauseThresholdPercent(value: number): this;
+    applicationJobQueueResumeThresholdPercent(value: number): this;
+}
+export interface ZLinkDispatchOptions {
+    readonly unhandled: ZLinkUnhandledDispatchOptions;
+    readonly diagnostics: ZLinkDiagnosticsOptions;
+}
+export interface ZLinkDispatchOptionsBuilder {
+    messageFlow(mode: ZLinkMessageFlowLogMode): this;
+    traceSampleRate(rate: number): this;
+    includeMessageSizes(include: boolean): this;
+}
+/**
+ * A message lifecycle outcome. Error outcomes carry the dispatch error fields on the
+ * same typed event used by the success path.
+ */
+export declare enum ZLinkRuntimeMessageFlowOutcome {
+    Received = "received",
+    Admitted = "admitted",
+    Dispatched = "dispatched",
+    Completed = "completed",
+    Replied = "replied",
+    Dropped = "dropped",
+    Sent = "sent",
+    ReplyReceived = "replyReceived",
+    Backpressured = "backpressured",
+    Error = "error"
+}
+export type ZLinkRuntimeMessageFlowResult = 'succeeded' | 'failed' | 'backpressured' | 'dropped' | 'cancelled' | 'shutdown';
+export interface ZLinkRuntimeMessageFlowEvent {
+    readonly outcome: ZLinkRuntimeMessageFlowOutcome;
+    readonly result?: ZLinkRuntimeMessageFlowResult;
+    readonly surface: ZLinkDispatchErrorSurface;
+    readonly messageKind: ZLinkDispatchMessageKind;
+    readonly packetName?: string;
+    readonly channelName?: string;
+    readonly channelRouteKind?: 'route_mesh' | 'client_server';
+    readonly meshName?: string;
+    readonly topic?: string;
+    readonly correlationId?: string;
+    readonly sourceRid?: string;
+    readonly targetRid?: string;
+    readonly serverRid?: string;
+    readonly peerRid?: string;
+    readonly socketRole?: string;
+    readonly effectiveMode: ZLinkMessageFlowLogMode;
+    readonly flowId?: string;
+    readonly flowOrigin?: ZLinkFlowOrigin;
+    /** Source MeshNode lifecycle generation used only for flow-less sampling. */
+    readonly sourceMeshGeneration?: bigint | string;
+    readonly spotId?: string;
+    readonly instanceSpotType?: string;
+    readonly activationState?: 'activating' | 'ready' | 'closing';
+    readonly actorId?: string;
+    /** Internal service-wire command carried by a RouteMesh control record. */
+    readonly commandId?: number;
+    readonly messageSize?: number;
+    readonly durationSeconds?: number;
+    readonly errorReason?: ZLinkDispatchErrorReason;
+    readonly errorAction?: ZLinkDispatchErrorAction;
+    readonly errorType?: string;
+    readonly errorMessage?: string;
+    readonly errorCauseType?: string;
+    readonly errorCauseMessage?: string;
+}
+/**
+ * Resolve from the runtime to turn message-flow tracing on/off (or change verbosity)
+ * at runtime without a restart. Read live by every dispatch surface.
+ */
+export interface ZLinkMessageFlowControl {
+    /**
+     * Synchronous compatibility bridge. Do not call from a framework execution
+     * context such as a handler or callback; use setMessageFlowModeAsync there.
+     */
+    setMessageFlowMode(mode: ZLinkMessageFlowLogMode): void;
+    setMessageFlowModeAsync(mode: ZLinkMessageFlowLogMode): Promise<void>;
+    messageFlowMode(): ZLinkMessageFlowLogMode;
+}
+export interface ZLinkDispatchFailure {
+    readonly surface: ZLinkDispatchErrorSurface;
+    readonly messageKind: ZLinkDispatchMessageKind;
+    readonly reason: ZLinkDispatchErrorReason;
+    readonly action: ZLinkDispatchErrorAction;
+    readonly packetName?: string;
+    readonly channelName?: string;
+    readonly channelRouteKind?: 'route_mesh' | 'client_server';
+    readonly meshName?: string;
+    readonly topic?: string;
+    readonly spotId?: string;
+    readonly instanceSpotType?: string;
+    readonly activationState?: 'activating' | 'ready' | 'closing';
+    readonly actorId?: string;
+    readonly commandId?: number;
+    readonly sourceRid?: string;
+    readonly targetRid?: string;
+    readonly serverRid?: string;
+    readonly correlationId?: string;
+    readonly flowId?: string;
+    readonly flowOrigin?: ZLinkFlowOrigin;
+    readonly errorType?: string;
+    readonly errorMessage?: string;
+    readonly errorCauseType?: string;
+    readonly errorCauseMessage?: string;
+}
+export interface ZLinkUnhandledDispatchOptions {
+    request: ZLinkUnhandledDispatchAction;
+    send: ZLinkUnhandledDispatchAction;
+    publish: ZLinkUnhandledDispatchAction;
+}
+export interface ZLinkDiagnosticsOptions {
+    messageFlow: ZLinkMessageFlowLogMode;
+    sampleRate: number;
+    includeMessageSizes: boolean;
+}
+export declare enum ZLinkUnhandledDispatchAction {
+    ReplyError = "replyError",
+    LogAndDrop = "logAndDrop",
+    Drop = "drop",
+    Throw = "throw"
+}
+export type ZLinkMessageFlowLogMode = 'off' | 'errors' | 'normal' | 'detailed';
+export declare const MESSAGE_FLOW_MODE_RANK: Record<ZLinkMessageFlowLogMode, number>;
+export declare enum ZLinkDispatchErrorSurface {
+    Node = "node",
+    Channel = "channel",
+    RouteMeshChannel = "routeMeshChannel",
+    SpotRoute = "spotRoute",
+    InstanceSpot = "instance_spot",
+    SpotSubscription = "spotSubscription",
+    SpotActor = "spotActor",
+    StreamSession = "streamSession",
+    ActorRelocation = "actorRelocation",
+    ClassicFanout = "classicFanout"
+}
+export declare enum ZLinkDispatchMessageKind {
+    Request = "request",
+    Send = "send",
+    Publish = "publish",
+    Response = "response",
+    Error = "error",
+    Control = "control",
+    ActorRequest = "actorRequest",
+    ActorSend = "actorSend"
+}
+export type ZLinkDispatchErrorReason = 'no_handler' | 'decode_error' | 'handler_exception' | 'invalid_frame' | 'reply_path_missing' | 'unexpected_reply' | 'backpressure' | 'stale_target' | 'shutdown';
+export type ZLinkDispatchErrorAction = 'reply_error' | 'fail_caller' | 'drop';
+export declare enum ZLinkRuntimeDispatchErrorReason {
+    HandlerMissing = "no_handler",
+    PayloadDecodeFailed = "decode_error",
+    HandlerException = "handler_exception",
+    InvalidFrame = "invalid_frame",
+    ReplyPathMissing = "reply_path_missing",
+    UnexpectedReply = "unexpected_reply",
+    Backpressure = "backpressure",
+    StaleTarget = "stale_target",
+    Shutdown = "shutdown"
+}
+export declare enum ZLinkRuntimeDispatchErrorAction {
+    ReplyError = "reply_error",
+    FailCaller = "fail_caller",
+    Drop = "drop"
+}

package/dist/contracts/Dispatch/ZLinkDispatchOptions.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRuntimeDispatchErrorAction = exports.ZLinkRuntimeDispatchErrorReason = exports.ZLinkDispatchMessageKind = exports.ZLinkDispatchErrorSurface = exports.MESSAGE_FLOW_MODE_RANK = exports.ZLinkUnhandledDispatchAction = exports.ZLinkRuntimeMessageFlowOutcome = exports.ZLinkApplicationJobQueueProfile = exports.ZLinkCoreHwmProfile = void 0;
+var ZLinkCoreHwmProfile;
+(function (ZLinkCoreHwmProfile) {
+    ZLinkCoreHwmProfile["Compact"] = "compact";
+    ZLinkCoreHwmProfile["LowLatency"] = "low_latency";
+    ZLinkCoreHwmProfile["Balanced"] = "balanced";
+    ZLinkCoreHwmProfile["Throughput"] = "throughput";
+})(ZLinkCoreHwmProfile || (exports.ZLinkCoreHwmProfile = ZLinkCoreHwmProfile = {}));
+var ZLinkApplicationJobQueueProfile;
+(function (ZLinkApplicationJobQueueProfile) {
+    ZLinkApplicationJobQueueProfile["Compact"] = "compact";
+    ZLinkApplicationJobQueueProfile["LowLatency"] = "low_latency";
+    ZLinkApplicationJobQueueProfile["Balanced"] = "balanced";
+    ZLinkApplicationJobQueueProfile["Throughput"] = "throughput";
+})(ZLinkApplicationJobQueueProfile || (exports.ZLinkApplicationJobQueueProfile = ZLinkApplicationJobQueueProfile = {}));
+/**
+ * A message lifecycle outcome. Error outcomes carry the dispatch error fields on the
+ * same typed event used by the success path.
+ */
+var ZLinkRuntimeMessageFlowOutcome;
+(function (ZLinkRuntimeMessageFlowOutcome) {
+    ZLinkRuntimeMessageFlowOutcome["Received"] = "received";
+    ZLinkRuntimeMessageFlowOutcome["Admitted"] = "admitted";
+    ZLinkRuntimeMessageFlowOutcome["Dispatched"] = "dispatched";
+    ZLinkRuntimeMessageFlowOutcome["Completed"] = "completed";
+    ZLinkRuntimeMessageFlowOutcome["Replied"] = "replied";
+    ZLinkRuntimeMessageFlowOutcome["Dropped"] = "dropped";
+    ZLinkRuntimeMessageFlowOutcome["Sent"] = "sent";
+    ZLinkRuntimeMessageFlowOutcome["ReplyReceived"] = "replyReceived";
+    ZLinkRuntimeMessageFlowOutcome["Backpressured"] = "backpressured";
+    ZLinkRuntimeMessageFlowOutcome["Error"] = "error";
+})(ZLinkRuntimeMessageFlowOutcome || (exports.ZLinkRuntimeMessageFlowOutcome = ZLinkRuntimeMessageFlowOutcome = {}));
+var ZLinkUnhandledDispatchAction;
+(function (ZLinkUnhandledDispatchAction) {
+    ZLinkUnhandledDispatchAction["ReplyError"] = "replyError";
+    ZLinkUnhandledDispatchAction["LogAndDrop"] = "logAndDrop";
+    ZLinkUnhandledDispatchAction["Drop"] = "drop";
+    ZLinkUnhandledDispatchAction["Throw"] = "throw";
+})(ZLinkUnhandledDispatchAction || (exports.ZLinkUnhandledDispatchAction = ZLinkUnhandledDispatchAction = {}));
+exports.MESSAGE_FLOW_MODE_RANK = {
+    off: 0,
+    errors: 1,
+    normal: 2,
+    detailed: 3
+};
+var ZLinkDispatchErrorSurface;
+(function (ZLinkDispatchErrorSurface) {
+    ZLinkDispatchErrorSurface["Node"] = "node";
+    ZLinkDispatchErrorSurface["Channel"] = "channel";
+    ZLinkDispatchErrorSurface["RouteMeshChannel"] = "routeMeshChannel";
+    ZLinkDispatchErrorSurface["SpotRoute"] = "spotRoute";
+    ZLinkDispatchErrorSurface["InstanceSpot"] = "instance_spot";
+    ZLinkDispatchErrorSurface["SpotSubscription"] = "spotSubscription";
+    ZLinkDispatchErrorSurface["SpotActor"] = "spotActor";
+    ZLinkDispatchErrorSurface["StreamSession"] = "streamSession";
+    ZLinkDispatchErrorSurface["ActorRelocation"] = "actorRelocation";
+    ZLinkDispatchErrorSurface["ClassicFanout"] = "classicFanout";
+})(ZLinkDispatchErrorSurface || (exports.ZLinkDispatchErrorSurface = ZLinkDispatchErrorSurface = {}));
+var ZLinkDispatchMessageKind;
+(function (ZLinkDispatchMessageKind) {
+    ZLinkDispatchMessageKind["Request"] = "request";
+    ZLinkDispatchMessageKind["Send"] = "send";
+    ZLinkDispatchMessageKind["Publish"] = "publish";
+    ZLinkDispatchMessageKind["Response"] = "response";
+    ZLinkDispatchMessageKind["Error"] = "error";
+    ZLinkDispatchMessageKind["Control"] = "control";
+    ZLinkDispatchMessageKind["ActorRequest"] = "actorRequest";
+    ZLinkDispatchMessageKind["ActorSend"] = "actorSend";
+})(ZLinkDispatchMessageKind || (exports.ZLinkDispatchMessageKind = ZLinkDispatchMessageKind = {}));
+var ZLinkRuntimeDispatchErrorReason;
+(function (ZLinkRuntimeDispatchErrorReason) {
+    ZLinkRuntimeDispatchErrorReason["HandlerMissing"] = "no_handler";
+    ZLinkRuntimeDispatchErrorReason["PayloadDecodeFailed"] = "decode_error";
+    ZLinkRuntimeDispatchErrorReason["HandlerException"] = "handler_exception";
+    ZLinkRuntimeDispatchErrorReason["InvalidFrame"] = "invalid_frame";
+    ZLinkRuntimeDispatchErrorReason["ReplyPathMissing"] = "reply_path_missing";
+    ZLinkRuntimeDispatchErrorReason["UnexpectedReply"] = "unexpected_reply";
+    ZLinkRuntimeDispatchErrorReason["Backpressure"] = "backpressure";
+    ZLinkRuntimeDispatchErrorReason["StaleTarget"] = "stale_target";
+    ZLinkRuntimeDispatchErrorReason["Shutdown"] = "shutdown";
+})(ZLinkRuntimeDispatchErrorReason || (exports.ZLinkRuntimeDispatchErrorReason = ZLinkRuntimeDispatchErrorReason = {}));
+var ZLinkRuntimeDispatchErrorAction;
+(function (ZLinkRuntimeDispatchErrorAction) {
+    ZLinkRuntimeDispatchErrorAction["ReplyError"] = "reply_error";
+    ZLinkRuntimeDispatchErrorAction["FailCaller"] = "fail_caller";
+    ZLinkRuntimeDispatchErrorAction["Drop"] = "drop";
+})(ZLinkRuntimeDispatchErrorAction || (exports.ZLinkRuntimeDispatchErrorAction = ZLinkRuntimeDispatchErrorAction = {}));

package/dist/contracts/Dispatch/ZLinkFlowOrigin.d.ts

@@ -0,0 +1 @@
+export type ZLinkFlowOrigin = 'Inbound' | 'Timer' | 'Application' | 'Lifecycle';

package/dist/contracts/Dispatch/ZLinkFlowOrigin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/Dispatch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ZLinkDispatchOptions';
+export * from './ZLinkFlowOrigin';

package/dist/contracts/Dispatch/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ZLinkDispatchOptions"), exports);
+__exportStar(require("./ZLinkFlowOrigin"), exports);

package/dist/contracts/Errors/ZLinkFrameworkException.d.ts

@@ -0,0 +1,20 @@
+/** Application-visible Framework error categories. */
+export declare enum ZLinkFrameworkErrorKind {
+    NotFound = 0,
+    AlreadyExists = 1,
+    TypeMismatch = 2,
+    NotConfigured = 3,
+    Rejected = 4,
+    Unavailable = 5,
+    CapacityExceeded = 6,
+    DeadlineExceeded = 7,
+    ShuttingDown = 8,
+    ProtocolError = 9,
+    InvalidOperation = 10,
+    DataLost = 11,
+    InternalFailure = 12
+}
+export declare class ZLinkFrameworkException extends Error {
+    readonly kind: ZLinkFrameworkErrorKind;
+    constructor(kind: ZLinkFrameworkErrorKind, message: string, cause?: unknown);
+}

package/dist/contracts/Errors/ZLinkFrameworkException.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkFrameworkException = exports.ZLinkFrameworkErrorKind = void 0;
+/** Application-visible Framework error categories. */
+var ZLinkFrameworkErrorKind;
+(function (ZLinkFrameworkErrorKind) {
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["NotFound"] = 0] = "NotFound";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["AlreadyExists"] = 1] = "AlreadyExists";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["TypeMismatch"] = 2] = "TypeMismatch";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["NotConfigured"] = 3] = "NotConfigured";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["Rejected"] = 4] = "Rejected";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["Unavailable"] = 5] = "Unavailable";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["CapacityExceeded"] = 6] = "CapacityExceeded";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["DeadlineExceeded"] = 7] = "DeadlineExceeded";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["ShuttingDown"] = 8] = "ShuttingDown";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["ProtocolError"] = 9] = "ProtocolError";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["InvalidOperation"] = 10] = "InvalidOperation";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["DataLost"] = 11] = "DataLost";
+    ZLinkFrameworkErrorKind[ZLinkFrameworkErrorKind["InternalFailure"] = 12] = "InternalFailure";
+})(ZLinkFrameworkErrorKind || (exports.ZLinkFrameworkErrorKind = ZLinkFrameworkErrorKind = {}));
+class ZLinkFrameworkException extends Error {
+    kind;
+    constructor(kind, message, cause) {
+        super(message, { cause });
+        this.kind = kind;
+        this.name = 'ZLinkFrameworkException';
+    }
+}
+exports.ZLinkFrameworkException = ZLinkFrameworkException;

package/dist/contracts/Errors/index.d.ts

@@ -0,0 +1 @@
+export { ZLinkFrameworkErrorKind, ZLinkFrameworkException } from './ZLinkFrameworkException';

package/dist/contracts/Errors/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkFrameworkException = exports.ZLinkFrameworkErrorKind = void 0;
+var ZLinkFrameworkException_1 = require("./ZLinkFrameworkException");
+Object.defineProperty(exports, "ZLinkFrameworkErrorKind", { enumerable: true, get: function () { return ZLinkFrameworkException_1.ZLinkFrameworkErrorKind; } });
+Object.defineProperty(exports, "ZLinkFrameworkException", { enumerable: true, get: function () { return ZLinkFrameworkException_1.ZLinkFrameworkException; } });

package/dist/contracts/Eventing/Metrics.d.ts

@@ -0,0 +1,29 @@
+export declare const ZLinkMeters: Readonly<{
+    readonly Framework: "zlink.framework";
+}>;
+export interface ZLinkMetricAttributes {
+    readonly [name: string]: string | number | boolean;
+}
+export interface ZLinkMetricInstrument {
+    add(value: number, attributes?: ZLinkMetricAttributes): void;
+}
+export interface ZLinkMetricHistogram {
+    record(value: number, attributes?: ZLinkMetricAttributes): void;
+}
+export interface ZLinkMeter {
+    createCounter(name: string, options?: {
+        readonly unit?: string;
+    }): ZLinkMetricInstrument;
+    createUpDownCounter(name: string, options?: {
+        readonly unit?: string;
+    }): ZLinkMetricInstrument;
+    createHistogram(name: string, options?: {
+        readonly unit?: string;
+    }): ZLinkMetricHistogram;
+}
+export interface ZLinkMeterProvider {
+    getMeter(name: string): ZLinkMeter;
+}
+export interface ZLinkMetricsOptions {
+    readonly meterProvider?: ZLinkMeterProvider;
+}

package/dist/contracts/Eventing/Metrics.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkMeters = void 0;
+exports.ZLinkMeters = Object.freeze({ Framework: 'zlink.framework' });

package/dist/contracts/Eventing/index.d.ts

@@ -0,0 +1 @@
+export * from './Metrics';

package/dist/contracts/Eventing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Metrics"), exports);

package/dist/contracts/Handlers/Attributes.d.ts

@@ -0,0 +1,24 @@
+import { type ZLinkPacketJsonContract } from './JsonContract';
+export declare const ZLINK_DECORATOR_METADATA: unique symbol;
+export interface ZLinkDecoratorMetadata {
+    readonly kind: string;
+    readonly packetName?: string;
+    readonly groupName?: string;
+    readonly methodName?: string;
+    readonly meshName?: string;
+    readonly channelName?: string;
+    readonly topic?: string;
+    readonly jsonContract?: ZLinkPacketJsonContract;
+}
+export declare function ZLinkHandlerGroup(groupName: string): ClassDecorator;
+export declare function ZLinkRequest(packetName?: string): MethodDecorator;
+export declare function ZLinkSend(packetName?: string): MethodDecorator;
+export declare function ZLinkPublish(packetName?: string): MethodDecorator;
+export declare function ZLinkPacket(packetName: string): ClassDecorator;
+export declare function ZLinkSpotRequest(packetName?: string): MethodDecorator;
+export declare function ZLinkSpotSubscription(channelName: string, topic: string): MethodDecorator;
+export declare function ZLinkSpotActorSend(packetName?: string): MethodDecorator;
+export declare function ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
+export declare function ZLinkStreamPacket(): MethodDecorator;
+export declare function ZLinkStreamRaw(): MethodDecorator;
+export declare function readZLinkDecoratorMetadata(target: object): readonly ZLinkDecoratorMetadata[];

package/dist/contracts/Handlers/Attributes.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_DECORATOR_METADATA = void 0;
+exports.ZLinkHandlerGroup = ZLinkHandlerGroup;
+exports.ZLinkRequest = ZLinkRequest;
+exports.ZLinkSend = ZLinkSend;
+exports.ZLinkPublish = ZLinkPublish;
+exports.ZLinkPacket = ZLinkPacket;
+exports.readZLinkPacketJsonContract = readZLinkPacketJsonContract;
+exports.ZLinkSpotRequest = ZLinkSpotRequest;
+exports.ZLinkSpotSubscription = ZLinkSpotSubscription;
+exports.ZLinkSpotActorSend = ZLinkSpotActorSend;
+exports.ZLinkSpotActorRequest = ZLinkSpotActorRequest;
+exports.ZLinkStreamPacket = ZLinkStreamPacket;
+exports.ZLinkStreamRaw = ZLinkStreamRaw;
+exports.readZLinkDecoratorMetadata = readZLinkDecoratorMetadata;
+const JsonContract_1 = require("./JsonContract");
+exports.ZLINK_DECORATOR_METADATA = Symbol.for('@zlink-systems/framework:decorator');
+function ZLinkHandlerGroup(groupName) {
+    return classDecorator({ kind: 'handlerGroup', groupName });
+}
+function ZLinkRequest(packetName) {
+    return methodDecorator({ kind: 'request', packetName });
+}
+function ZLinkSend(packetName) {
+    return methodDecorator({ kind: 'send', packetName });
+}
+function ZLinkPublish(packetName) {
+    return methodDecorator({ kind: 'publish', packetName });
+}
+function ZLinkPacket(packetName, jsonContract) {
+    return (target) => {
+        const normalized = jsonContract === undefined
+            ? undefined
+            : (0, JsonContract_1.defineZLinkPacketJsonContract)(packetName, jsonContract);
+        appendMetadata(target, { kind: 'packet', packetName, jsonContract: normalized });
+    };
+}
+/** @internal */
+function readZLinkPacketJsonContract(packetName) {
+    return (0, JsonContract_1.readZLinkPacketJsonContract)(packetName);
+}
+function ZLinkSpotRequest(packetName) {
+    return methodDecorator({ kind: 'spotRequest', packetName });
+}
+function ZLinkSpotSubscription(channelName, topic) {
+    return methodDecorator({ kind: 'spotSubscription', channelName, topic });
+}
+function ZLinkSpotActorSend(packetName) {
+    return methodDecorator({ kind: 'spotActorSend', packetName });
+}
+function ZLinkSpotActorRequest(packetName) {
+    return methodDecorator({ kind: 'spotActorRequest', packetName });
+}
+function ZLinkStreamPacket() {
+    return methodDecorator({ kind: 'streamPacket' });
+}
+function ZLinkStreamRaw() {
+    return methodDecorator({ kind: 'streamRaw' });
+}
+function classDecorator(metadata) {
+    return (target) => appendMetadata(target, metadata);
+}
+function methodDecorator(metadata) {
+    return (target, propertyKey) => appendMetadata(target.constructor, {
+        ...metadata,
+        methodName: String(propertyKey)
+    });
+}
+function appendMetadata(target, metadata) {
+    const current = readZLinkDecoratorMetadata(target);
+    Object.defineProperty(target, exports.ZLINK_DECORATOR_METADATA, {
+        configurable: true,
+        enumerable: false,
+        value: [...current, metadata],
+        writable: false
+    });
+}
+function readZLinkDecoratorMetadata(target) {
+    if (!Object.prototype.hasOwnProperty.call(target, exports.ZLINK_DECORATOR_METADATA)) {
+        return [];
+    }
+    return target[exports.ZLINK_DECORATOR_METADATA];
+}

package/dist/contracts/Handlers/Contexts.d.ts

@@ -0,0 +1,18 @@
+import type { RoutingId, ZLinkMessageMetadata } from '../Common';
+export interface ZLinkMessageContext {
+    readonly meshName?: string;
+    readonly channelName?: string;
+    readonly packetName: string;
+    readonly contentType?: string;
+    readonly metadata: ZLinkMessageMetadata;
+    readonly correlationId?: string;
+}
+export interface ZLinkPublishMessageContext extends ZLinkMessageContext {
+    readonly channelName: string;
+    readonly topic: string;
+    readonly source?: string;
+}
+export interface ZLinkRouteMessageContext extends ZLinkMessageContext {
+    readonly meshName: string;
+    readonly sourceNodeRid: RoutingId;
+}

package/dist/contracts/Handlers/Contexts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/Handlers/IZLinkChannelHandlers.d.ts

@@ -0,0 +1,43 @@
+import type { ZLinkActor } from '../Actors';
+import type { ZLinkEntrySpot } from '../Spots';
+import type { ZLinkTimerTick } from '../Timers';
+import type { ZLinkMessageContext, ZLinkPublishMessageContext, ZLinkRouteMessageContext } from './Contexts';
+export interface ZLinkRequestHandler<TRequest, TResponse> {
+    handle(request: TRequest, context: ZLinkMessageContext): Promise<TResponse>;
+}
+export interface ZLinkSendHandler<TMessage> {
+    handle(message: TMessage, context: ZLinkMessageContext): Promise<void>;
+}
+export interface ZLinkRouteSendHandler<TMessage> {
+    handle(message: TMessage, context: ZLinkRouteMessageContext): Promise<void>;
+}
+export interface ZLinkRouteRequestHandler<TRequest, TReply> {
+    handle(request: TRequest, context: ZLinkRouteMessageContext): Promise<TReply>;
+}
+export interface ZLinkFanoutHandler<TMessage> {
+    handle(message: TMessage, context: ZLinkPublishMessageContext): Promise<void>;
+}
+export interface ZLinkSpotPacketHandler<TSpot, TMessage> {
+    handle(spot: TSpot, message: TMessage, context: ZLinkMessageContext): Promise<void>;
+}
+export interface ZLinkSpotRequestHandler<TSpot, TRequest, TReply> {
+    handle(spot: TSpot, request: TRequest, context: ZLinkMessageContext): Promise<TReply>;
+}
+export interface ZLinkSpotSubscriptionHandler<TSpot, TEvent> {
+    handle(spot: TSpot, event: TEvent, context: ZLinkPublishMessageContext): Promise<void>;
+}
+export interface ZLinkSpotTimerHandler<TSpot> {
+    handle(spot: TSpot, tick: ZLinkTimerTick): Promise<void>;
+}
+export interface ZLinkSpotActorSendHandler<TSpot, TActor extends ZLinkActor, TMessage> {
+    handle(spot: TSpot, actor: TActor, context: ZLinkMessageContext, message: TMessage): Promise<void>;
+}
+export interface ZLinkSpotActorRequestHandler<TSpot, TActor extends ZLinkActor, TRequest, TReply> {
+    handle(spot: TSpot, actor: TActor, context: ZLinkMessageContext, request: TRequest): Promise<TReply>;
+}
+export interface ZLinkEntrySpotActorSendHandler<TEntrySpot extends ZLinkEntrySpot<TActor>, TActor extends ZLinkActor, TMessage> {
+    handle(spot: TEntrySpot, actor: TActor, context: ZLinkMessageContext, message: TMessage): Promise<void>;
+}
+export interface ZLinkEntrySpotActorRequestHandler<TEntrySpot extends ZLinkEntrySpot<TActor>, TActor extends ZLinkActor, TRequest, TReply> {
+    handle(spot: TEntrySpot, actor: TActor, context: ZLinkMessageContext, request: TRequest): Promise<TReply>;
+}

package/dist/contracts/Handlers/IZLinkChannelHandlers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/Handlers/IZLinkHandlerFilter.d.ts

@@ -0,0 +1,15 @@
+import type { ZLinkHandlerFilterNext } from './ZLinkHandlerFilterNext';
+import type { ZLinkMessageContext } from './Contexts';
+export declare enum ZLinkHandlerDispatchKind {
+    NodeDirectSend = "nodeDirectSend",
+    NodeDirectRequest = "nodeDirectRequest",
+    ChannelSend = "channelSend",
+    ChannelRequest = "channelRequest",
+    ClassicFanout = "classicFanout"
+}
+export interface ZLinkHandlerFilterContext extends ZLinkMessageContext {
+    readonly dispatchKind: ZLinkHandlerDispatchKind;
+}
+export interface ZLinkHandlerFilter {
+    invoke(context: ZLinkHandlerFilterContext, next: ZLinkHandlerFilterNext, signal?: AbortSignal): Promise<void>;
+}

package/dist/contracts/Handlers/IZLinkHandlerFilter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkHandlerDispatchKind = void 0;
+var ZLinkHandlerDispatchKind;
+(function (ZLinkHandlerDispatchKind) {
+    ZLinkHandlerDispatchKind["NodeDirectSend"] = "nodeDirectSend";
+    ZLinkHandlerDispatchKind["NodeDirectRequest"] = "nodeDirectRequest";
+    ZLinkHandlerDispatchKind["ChannelSend"] = "channelSend";
+    ZLinkHandlerDispatchKind["ChannelRequest"] = "channelRequest";
+    ZLinkHandlerDispatchKind["ClassicFanout"] = "classicFanout";
+})(ZLinkHandlerDispatchKind || (exports.ZLinkHandlerDispatchKind = ZLinkHandlerDispatchKind = {}));