@benzenejs/mesh-dispatch 0.0.0-stage → 0.1.0-beta.2

package/dist/Extensions.d.ts

@@ -0,0 +1,13 @@
+import { IMiddlewarePipelineBuilder } from '@benzenejs/abstractions-middleware';
+import { MeshDispatchOptions } from './MeshDispatchOptions';
+/** The reserved-style topic the dispatch handler is served on. */
+export declare const DispatchTopic = "benzene:mesh:dispatch";
+/**
+ * Registers the opt-in `benzene:mesh:dispatch` handler, which invokes ONE registered service's real handler with a
+ * caller-supplied payload. Opt-in by construction AND gated at runtime (refused in Production unless
+ * `MeshDispatchOptions.allowInProduction` is set). C# extension method -> free function taking the builder.
+ *
+ * Requires a `MeshServiceRegistry` registered in the same container, and at least one
+ * `IMeshServiceDispatcher` for the transports in use (the HTTP dispatcher is registered here).
+ */
+export declare function useMeshDispatch<TContext>(app: IMiddlewarePipelineBuilder<TContext>, options?: MeshDispatchOptions): IMiddlewarePipelineBuilder<TContext>;

package/dist/Extensions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DispatchTopic = void 0;
+exports.useMeshDispatch = useMeshDispatch;
+/** Port of Benzene.Mesh.Dispatch.Extensions. */
+const abstractions_1 = require("@benzenejs/abstractions");
+const abstractions_message_handlers_1 = require("@benzenejs/abstractions-message-handlers");
+const core_message_handlers_1 = require("@benzenejs/core-message-handlers");
+const core_messages_1 = require("@benzenejs/core-messages");
+const mesh_contracts_1 = require("@benzenejs/mesh-contracts");
+const IMeshDispatchEnvironment_1 = require("./IMeshDispatchEnvironment");
+const HttpMeshServiceDispatcher_1 = require("./HttpMeshServiceDispatcher");
+const IMeshServiceDispatcher_1 = require("./IMeshServiceDispatcher");
+const MeshDispatchGate_1 = require("./MeshDispatchGate");
+const MeshDispatchMessageHandler_1 = require("./MeshDispatchMessageHandler");
+const MeshDispatchOptions_1 = require("./MeshDispatchOptions");
+const MeshDispatchRequest_1 = require("./MeshDispatchRequest");
+/** The reserved-style topic the dispatch handler is served on. */
+exports.DispatchTopic = 'benzene:mesh:dispatch';
+/**
+ * Registers the opt-in `benzene:mesh:dispatch` handler, which invokes ONE registered service's real handler with a
+ * caller-supplied payload. Opt-in by construction AND gated at runtime (refused in Production unless
+ * `MeshDispatchOptions.allowInProduction` is set). C# extension method -> free function taking the builder.
+ *
+ * Requires a `MeshServiceRegistry` registered in the same container, and at least one
+ * `IMeshServiceDispatcher` for the transports in use (the HTTP dispatcher is registered here).
+ */
+function useMeshDispatch(app, options) {
+    app.register((x) => {
+        x.addSingletonInstance(MeshDispatchOptions_1.MeshDispatchOptions, options ?? new MeshDispatchOptions_1.MeshDispatchOptions());
+        (0, abstractions_1.tryAddSingletonFactory)(x, IMeshDispatchEnvironment_1.IMeshDispatchEnvironment, () => new IMeshDispatchEnvironment_1.EnvironmentVariableMeshDispatchEnvironment());
+        x.addSingletonFactory(MeshDispatchGate_1.MeshDispatchGate, (r) => new MeshDispatchGate_1.MeshDispatchGate(r.getService(MeshDispatchOptions_1.MeshDispatchOptions), r.getService(IMeshDispatchEnvironment_1.IMeshDispatchEnvironment)));
+        x.addSingletonFactory(IMeshServiceDispatcher_1.IMeshServiceDispatcher, () => new HttpMeshServiceDispatcher_1.HttpMeshServiceDispatcher());
+        x.addSingletonInstance(abstractions_message_handlers_1.IMessageHandlerDefinition, core_message_handlers_1.MessageHandlerDefinition.createInstance(exports.DispatchTopic, '', MeshDispatchRequest_1.MeshDispatchRequest, core_messages_1.RawStringMessage, MeshDispatchMessageHandler_1.MeshDispatchMessageHandler));
+        x.addScopedFactory(MeshDispatchMessageHandler_1.MeshDispatchMessageHandler, (r) => new MeshDispatchMessageHandler_1.MeshDispatchMessageHandler(r.getService(MeshDispatchGate_1.MeshDispatchGate), r.getService(mesh_contracts_1.MeshServiceRegistry), r.getServices(IMeshServiceDispatcher_1.IMeshServiceDispatcher)));
+    });
+    return app;
+}

package/dist/HttpMeshServiceDispatcher.d.ts

@@ -0,0 +1,25 @@
+/** Port of Benzene.Mesh.Dispatch.HttpMeshServiceDispatcher. */
+import { MeshServiceRegistryEntry } from '@benzenejs/mesh-contracts';
+import { MeshDispatchEnvelope, MeshDispatchResult } from './MeshDispatchEnvelope';
+import { IMeshServiceDispatcher } from './IMeshServiceDispatcher';
+/** The `SourceOptions` key overriding the invoke URL. */
+export declare const InvokeUrlOption = "invokeUrl";
+/** The default envelope path a service is invoked on: `/benzene/invoke` (design-principles §5.2). */
+export declare const DefaultInvokePath = "/benzene/invoke";
+/** A `fetch`-like function - the port of C# `HttpClient.PostAsync` (`HttpClient` -> injectable `fetch`). */
+export type DispatchFetch = (url: string, init: RequestInit) => Promise<Response>;
+/**
+ * Dispatches to an HTTP-reachable service by POSTing the Benzene message envelope (`{ topic, headers, body }`)
+ * to its wire-envelope endpoint. The endpoint URL comes from the entry's `sourceOptions["invokeUrl"]` when
+ * present, otherwise derived from the entry's `specUrl` origin as `<origin>/benzene/invoke`.
+ *
+ * `HttpClient` -> an injectable `fetch` (default global `fetch`), the same adaptation as
+ * `@benzenejs/health-checks-http`. A `fetch` that rejects - the call failed before the service replied - is a
+ * `timeout` or `service-unavailable` result ({@link transportFailureDispatchResult}), not an exception.
+ */
+export declare class HttpMeshServiceDispatcher implements IMeshServiceDispatcher {
+    private readonly fetchFn;
+    constructor(fetchFn?: DispatchFetch);
+    get key(): string;
+    dispatchAsync(entry: MeshServiceRegistryEntry, envelope: MeshDispatchEnvelope, cancellationToken?: AbortSignal): Promise<MeshDispatchResult>;
+}

package/dist/HttpMeshServiceDispatcher.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMeshServiceDispatcher = exports.DefaultInvokePath = exports.InvokeUrlOption = void 0;
+/** Port of Benzene.Mesh.Dispatch.HttpMeshServiceDispatcher. */
+const mesh_contracts_1 = require("@benzenejs/mesh-contracts");
+const MeshDispatchEnvelope_1 = require("./MeshDispatchEnvelope");
+/** The `SourceOptions` key overriding the invoke URL. */
+exports.InvokeUrlOption = 'invokeUrl';
+/** The default envelope path a service is invoked on: `/benzene/invoke` (design-principles §5.2). */
+exports.DefaultInvokePath = '/benzene/invoke';
+/**
+ * Dispatches to an HTTP-reachable service by POSTing the Benzene message envelope (`{ topic, headers, body }`)
+ * to its wire-envelope endpoint. The endpoint URL comes from the entry's `sourceOptions["invokeUrl"]` when
+ * present, otherwise derived from the entry's `specUrl` origin as `<origin>/benzene/invoke`.
+ *
+ * `HttpClient` -> an injectable `fetch` (default global `fetch`), the same adaptation as
+ * `@benzenejs/health-checks-http`. A `fetch` that rejects - the call failed before the service replied - is a
+ * `timeout` or `service-unavailable` result ({@link transportFailureDispatchResult}), not an exception.
+ */
+class HttpMeshServiceDispatcher {
+    fetchFn;
+    constructor(fetchFn = fetch) {
+        this.fetchFn = fetchFn;
+    }
+    get key() {
+        return mesh_contracts_1.MeshServiceSource.http;
+    }
+    async dispatchAsync(entry, envelope, cancellationToken) {
+        const url = resolveInvokeUrl(entry);
+        const payload = JSON.stringify({
+            topic: envelope.topic,
+            headers: envelope.headers,
+            body: envelope.body,
+        });
+        let response;
+        try {
+            response = await this.fetchFn(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: payload,
+                signal: cancellationToken,
+            });
+        }
+        catch (error) {
+            // Failed before any reply (transport-bindings §1): a `timeout`/`service-unavailable` result, not a throw.
+            return (0, MeshDispatchEnvelope_1.transportFailureDispatchResult)(error);
+        }
+        const responseBody = await response.text();
+        // The envelope endpoint answers 200 for every envelope it processed, the outcome inside the envelope
+        // (transport-bindings §1, D17), so the result is read from the body whatever the status. Only a body
+        // that is not an envelope (a carrier failure, or a non-Benzene endpoint) falls back to the status line.
+        const replied = tryParseResponseEnvelope(responseBody);
+        return replied === undefined
+            ? new MeshDispatchEnvelope_1.MeshDispatchResult(String(response.status), responseBody)
+            : new MeshDispatchEnvelope_1.MeshDispatchResult(replied.statusCode, replied.body, replied.headers);
+    }
+}
+exports.HttpMeshServiceDispatcher = HttpMeshServiceDispatcher;
+function resolveInvokeUrl(entry) {
+    const explicitUrl = entry.sourceOptions?.[exports.InvokeUrlOption];
+    if (explicitUrl !== undefined && explicitUrl.trim() !== '') {
+        return explicitUrl;
+    }
+    if (entry.specUrl.trim() === '') {
+        throw new Error(`Mesh service "${entry.name}" has no "${exports.InvokeUrlOption}" in sourceOptions and no specUrl to derive an invoke URL from.`);
+    }
+    return new URL(entry.specUrl).origin + exports.DefaultInvokePath;
+}
+function tryParseResponseEnvelope(body) {
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed !== 'object' || parsed === null || typeof parsed.statusCode !== 'string') {
+            return undefined;
+        }
+        const envelope = parsed;
+        return {
+            statusCode: envelope.statusCode,
+            body: typeof envelope.body === 'string' ? envelope.body : undefined,
+            headers: typeof envelope.headers === 'object' && envelope.headers !== null
+                ? envelope.headers
+                : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/IMeshDispatchEnvironment.d.ts

@@ -0,0 +1,21 @@
+/** Port of Benzene.Mesh.Dispatch.IMeshDispatchEnvironment (+ EnvironmentVariableMeshDispatchEnvironment). */
+import { ServiceToken } from '@benzenejs/abstractions';
+/** Tells the dispatch gate whether the process is running in a Production environment. */
+export interface IMeshDispatchEnvironment {
+    /** Whether this process considers itself to be running in Production. */
+    readonly isProduction: boolean;
+}
+/** Container token: the gate resolves the environment by this interface. */
+export declare const IMeshDispatchEnvironment: ServiceToken<IMeshDispatchEnvironment>;
+/**
+ * Default {@link IMeshDispatchEnvironment} reading the environment from process env vars. An UNSET
+ * environment is treated as Production - the safe default, so dispatch is off unless the host is
+ * explicitly non-production (or `MeshDispatchOptions.allowInProduction` is set).
+ *
+ * DIVERGENCE: C# reads `ASPNETCORE_ENVIRONMENT`/`DOTNET_ENVIRONMENT`; the Node port reads `NODE_ENV` first
+ * (the Node convention) then falls back to those two for teams migrating from .NET. Production when the
+ * resolved value is empty/unset or equals `production`/`Production` (case-insensitive).
+ */
+export declare class EnvironmentVariableMeshDispatchEnvironment implements IMeshDispatchEnvironment {
+    get isProduction(): boolean;
+}

package/dist/IMeshDispatchEnvironment.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentVariableMeshDispatchEnvironment = exports.IMeshDispatchEnvironment = void 0;
+/** Port of Benzene.Mesh.Dispatch.IMeshDispatchEnvironment (+ EnvironmentVariableMeshDispatchEnvironment). */
+const abstractions_1 = require("@benzenejs/abstractions");
+/** Container token: the gate resolves the environment by this interface. */
+exports.IMeshDispatchEnvironment = (0, abstractions_1.serviceToken)('IMeshDispatchEnvironment');
+/**
+ * Default {@link IMeshDispatchEnvironment} reading the environment from process env vars. An UNSET
+ * environment is treated as Production - the safe default, so dispatch is off unless the host is
+ * explicitly non-production (or `MeshDispatchOptions.allowInProduction` is set).
+ *
+ * DIVERGENCE: C# reads `ASPNETCORE_ENVIRONMENT`/`DOTNET_ENVIRONMENT`; the Node port reads `NODE_ENV` first
+ * (the Node convention) then falls back to those two for teams migrating from .NET. Production when the
+ * resolved value is empty/unset or equals `production`/`Production` (case-insensitive).
+ */
+class EnvironmentVariableMeshDispatchEnvironment {
+    get isProduction() {
+        const environment = process.env.NODE_ENV ??
+            process.env.ASPNETCORE_ENVIRONMENT ??
+            process.env.DOTNET_ENVIRONMENT;
+        return (environment === undefined ||
+            environment.trim() === '' ||
+            environment.toLowerCase() === 'production');
+    }
+}
+exports.EnvironmentVariableMeshDispatchEnvironment = EnvironmentVariableMeshDispatchEnvironment;

package/dist/IMeshServiceDispatcher.d.ts

@@ -0,0 +1,17 @@
+/** Port of Benzene.Mesh.Dispatch.IMeshServiceDispatcher. */
+import { ServiceToken } from '@benzenejs/abstractions';
+import { MeshServiceRegistryEntry } from '@benzenejs/mesh-contracts';
+import { MeshDispatchEnvelope, MeshDispatchResult } from './MeshDispatchEnvelope';
+/**
+ * Dispatches a message to ONE target service over a specific transport - the write-side counterpart of the
+ * aggregator's read-only service source. Keyed by `MeshServiceRegistryEntry.source` so the handler picks
+ * the right transport per service. `CancellationToken` -> optional `AbortSignal`.
+ */
+export interface IMeshServiceDispatcher {
+    /** The `MeshServiceRegistryEntry.source` value this dispatcher handles. */
+    readonly key: string;
+    /** Sends `envelope` to the service described by `entry` and returns its response. */
+    dispatchAsync(entry: MeshServiceRegistryEntry, envelope: MeshDispatchEnvelope, cancellationToken?: AbortSignal): Promise<MeshDispatchResult>;
+}
+/** Container token: dispatchers are registered and collected via `getServices(IMeshServiceDispatcher)`. */
+export declare const IMeshServiceDispatcher: ServiceToken<IMeshServiceDispatcher>;

package/dist/IMeshServiceDispatcher.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMeshServiceDispatcher = void 0;
+/** Port of Benzene.Mesh.Dispatch.IMeshServiceDispatcher. */
+const abstractions_1 = require("@benzenejs/abstractions");
+/** Container token: dispatchers are registered and collected via `getServices(IMeshServiceDispatcher)`. */
+exports.IMeshServiceDispatcher = (0, abstractions_1.serviceToken)('IMeshServiceDispatcher');

package/dist/MeshDispatchEnvelope.d.ts

@@ -0,0 +1,25 @@
+/** The message to dispatch to a target service (the standard Benzene message envelope). */
+export declare class MeshDispatchEnvelope {
+    readonly topic: string;
+    readonly headers: Record<string, string>;
+    readonly body: string;
+    constructor(topic: string, headers: Record<string, string>, body: string);
+}
+/** The response a target service returned to a dispatched message. */
+export declare class MeshDispatchResult {
+    readonly statusCode: string;
+    readonly body: string | undefined;
+    readonly headers: Record<string, string>;
+    /**
+     * @param statusCode The status the service returned (a Benzene result status, or an HTTP status for HTTP targets).
+     * @param body The response body the service returned.
+     */
+    constructor(statusCode: string, body: string | undefined, headers?: Record<string, string>);
+}
+/**
+ * The {@link MeshDispatchResult} for a dispatch that failed before the target service replied - no
+ * connection, a refused or reset request, an aborted or timed-out call: `timeout` when the deadline elapsed,
+ * otherwise `service-unavailable`, with the failure's message as the body (transport-bindings.md §1, spec 1.1:
+ * a result, not an exception). A port addition shared by the HTTP and Lambda dispatchers.
+ */
+export declare function transportFailureDispatchResult(error: unknown): MeshDispatchResult;

package/dist/MeshDispatchEnvelope.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDispatchResult = exports.MeshDispatchEnvelope = void 0;
+exports.transportFailureDispatchResult = transportFailureDispatchResult;
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchEnvelope (+ MeshDispatchResult). */
+const results_1 = require("@benzenejs/results");
+/** The message to dispatch to a target service (the standard Benzene message envelope). */
+class MeshDispatchEnvelope {
+    topic;
+    headers;
+    body;
+    constructor(topic, headers, body) {
+        this.topic = topic;
+        this.headers = headers;
+        this.body = body;
+    }
+}
+exports.MeshDispatchEnvelope = MeshDispatchEnvelope;
+/** The response a target service returned to a dispatched message. */
+class MeshDispatchResult {
+    statusCode;
+    body;
+    headers;
+    /**
+     * @param statusCode The status the service returned (a Benzene result status, or an HTTP status for HTTP targets).
+     * @param body The response body the service returned.
+     */
+    constructor(statusCode, body, headers) {
+        this.statusCode = statusCode;
+        this.body = body;
+        this.headers = headers ?? {};
+    }
+}
+exports.MeshDispatchResult = MeshDispatchResult;
+/**
+ * The {@link MeshDispatchResult} for a dispatch that failed before the target service replied - no
+ * connection, a refused or reset request, an aborted or timed-out call: `timeout` when the deadline elapsed,
+ * otherwise `service-unavailable`, with the failure's message as the body (transport-bindings.md §1, spec 1.1:
+ * a result, not an exception). A port addition shared by the HTTP and Lambda dispatchers.
+ */
+function transportFailureDispatchResult(error) {
+    const result = (0, results_1.transportFailureResult)(error);
+    return new MeshDispatchResult(result.status, result.errors[0]?.message);
+}

package/dist/MeshDispatchGate.d.ts

@@ -0,0 +1,17 @@
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchGate. */
+import { IMeshDispatchEnvironment } from './IMeshDispatchEnvironment';
+import { MeshDispatchOptions } from './MeshDispatchOptions';
+/** Decides whether a dispatch is currently permitted, and gives the reason when it isn't. */
+export declare class MeshDispatchGate {
+    private readonly options;
+    private readonly environment;
+    constructor(options: MeshDispatchOptions, environment: IMeshDispatchEnvironment);
+    /**
+     * Dispatch is allowed only outside Production, unless `allowInProduction` is explicitly set. Firing a
+     * real handler with test data has real side-effects, so the default is off (an unset environment counts
+     * as Production).
+     */
+    get isAllowed(): boolean;
+    /** A human-readable reason dispatch is blocked, returned when {@link isAllowed} is false. */
+    get blockedReason(): string;
+}

package/dist/MeshDispatchGate.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDispatchGate = void 0;
+/** Decides whether a dispatch is currently permitted, and gives the reason when it isn't. */
+class MeshDispatchGate {
+    options;
+    environment;
+    constructor(options, environment) {
+        this.options = options;
+        this.environment = environment;
+    }
+    /**
+     * Dispatch is allowed only outside Production, unless `allowInProduction` is explicitly set. Firing a
+     * real handler with test data has real side-effects, so the default is off (an unset environment counts
+     * as Production).
+     */
+    get isAllowed() {
+        return !this.environment.isProduction || this.options.allowInProduction;
+    }
+    /** A human-readable reason dispatch is blocked, returned when {@link isAllowed} is false. */
+    get blockedReason() {
+        return ('Mesh dispatch is disabled in this environment. It invokes a service\'s real handler with the ' +
+            'supplied payload (real side-effects execute), so it is off in Production unless ' +
+            'MeshDispatchOptions.allowInProduction is explicitly set.');
+    }
+}
+exports.MeshDispatchGate = MeshDispatchGate;

package/dist/MeshDispatchMessageHandler.d.ts

@@ -0,0 +1,21 @@
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchMessageHandler. */
+import { IBenzeneResultOf } from '@benzenejs/abstractions';
+import { IMessageHandler } from '@benzenejs/abstractions-message-handlers';
+import { RawStringMessage } from '@benzenejs/core-messages';
+import { MeshServiceRegistry } from '@benzenejs/mesh-contracts';
+import { IMeshServiceDispatcher } from './IMeshServiceDispatcher';
+import { MeshDispatchGate } from './MeshDispatchGate';
+import { MeshDispatchRequest } from './MeshDispatchRequest';
+/**
+ * Serves the `benzene:mesh:dispatch` topic: invokes ONE registered service's real handler with a caller-supplied
+ * payload and returns its response. Off unless {@link MeshDispatchGate.isAllowed} (opt-in registration AND
+ * non-Production / allowInProduction) - a real handler runs, with real side-effects. Bounded to one
+ * declared service, never a shared queue.
+ */
+export declare class MeshDispatchMessageHandler implements IMessageHandler<MeshDispatchRequest, RawStringMessage> {
+    private readonly gate;
+    private readonly registry;
+    private readonly dispatchers;
+    constructor(gate: MeshDispatchGate, registry: MeshServiceRegistry, dispatchers: Iterable<IMeshServiceDispatcher>);
+    handleAsync(request: MeshDispatchRequest): Promise<IBenzeneResultOf<RawStringMessage>>;
+}

package/dist/MeshDispatchMessageHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDispatchMessageHandler = void 0;
+const core_messages_1 = require("@benzenejs/core-messages");
+const results_1 = require("@benzenejs/results");
+const MeshDispatchEnvelope_1 = require("./MeshDispatchEnvelope");
+/**
+ * Serves the `benzene:mesh:dispatch` topic: invokes ONE registered service's real handler with a caller-supplied
+ * payload and returns its response. Off unless {@link MeshDispatchGate.isAllowed} (opt-in registration AND
+ * non-Production / allowInProduction) - a real handler runs, with real side-effects. Bounded to one
+ * declared service, never a shared queue.
+ */
+class MeshDispatchMessageHandler {
+    gate;
+    registry;
+    dispatchers;
+    constructor(gate, registry, dispatchers) {
+        this.gate = gate;
+        this.registry = registry;
+        this.dispatchers = [...dispatchers];
+    }
+    async handleAsync(request) {
+        if (!this.gate.isAllowed) {
+            return results_1.BenzeneResult.forbidden(this.gate.blockedReason);
+        }
+        if (request === undefined ||
+            request === null ||
+            (request.service ?? '').trim() === '' ||
+            (request.topic ?? '').trim() === '') {
+            return results_1.BenzeneResult.badRequest("A dispatch request needs both a 'service' and a 'topic'.");
+        }
+        const service = request.service;
+        const entry = this.registry.services.find((s) => s.name.toLowerCase() === service.toLowerCase());
+        if (entry === undefined) {
+            return results_1.BenzeneResult.notFound(`No service named '${service}' is registered in the mesh.`);
+        }
+        const dispatcher = this.dispatchers.find((d) => d.key.toLowerCase() === entry.source.toLowerCase());
+        if (dispatcher === undefined) {
+            return results_1.BenzeneResult.setErrors(results_1.BenzeneResultStatus.notImplemented, `No dispatcher is registered for source '${entry.source}' (service '${entry.name}'). ` +
+                'Register the matching transport dispatcher (e.g. addMeshLambdaDispatcher() for AwsLambdaInvoke).');
+        }
+        const envelope = new MeshDispatchEnvelope_1.MeshDispatchEnvelope(request.topic, request.headers ?? {}, request.body ?? '');
+        const result = await dispatcher.dispatchAsync(entry, envelope);
+        const json = JSON.stringify(result);
+        return results_1.BenzeneResult.ok(new core_messages_1.RawStringMessage(json));
+    }
+}
+exports.MeshDispatchMessageHandler = MeshDispatchMessageHandler;

package/dist/MeshDispatchOptions.d.ts

@@ -0,0 +1,10 @@
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchOptions. */
+/** Configuration for the opt-in mesh dispatch feature. Resolved from the container by its own class. */
+export declare class MeshDispatchOptions {
+    /**
+     * Whether dispatch is permitted in Production. Defaults to `false`: a dispatch invokes a target
+     * service's REAL handler with caller-supplied data (real side-effects execute), so it stays off in
+     * Production unless a human deliberately opts in.
+     */
+    allowInProduction: boolean;
+}

package/dist/MeshDispatchOptions.js

@@ -0,0 +1,14 @@
+"use strict";
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchOptions. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDispatchOptions = void 0;
+/** Configuration for the opt-in mesh dispatch feature. Resolved from the container by its own class. */
+class MeshDispatchOptions {
+    /**
+     * Whether dispatch is permitted in Production. Defaults to `false`: a dispatch invokes a target
+     * service's REAL handler with caller-supplied data (real side-effects execute), so it stays off in
+     * Production unless a human deliberately opts in.
+     */
+    allowInProduction = false;
+}
+exports.MeshDispatchOptions = MeshDispatchOptions;

package/dist/MeshDispatchRequest.d.ts

@@ -0,0 +1,15 @@
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchRequest. */
+/**
+ * A request to dispatch a test message to one registered service (the `benzene:mesh:dispatch` body). Plain
+ * settable fields (wire-deserialized input); `string?`/`Dictionary?` -> `| undefined`.
+ */
+export declare class MeshDispatchRequest {
+    /** The target service's name (its key in the mesh registry). */
+    service: string | undefined;
+    /** The topic to invoke on the target service. */
+    topic: string | undefined;
+    /** Message headers to carry (optional). */
+    headers: Record<string, string> | undefined;
+    /** The serialized message body (optional). */
+    body: string | undefined;
+}

package/dist/MeshDispatchRequest.js

@@ -0,0 +1,19 @@
+"use strict";
+/** Port of Benzene.Mesh.Dispatch.MeshDispatchRequest. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDispatchRequest = void 0;
+/**
+ * A request to dispatch a test message to one registered service (the `benzene:mesh:dispatch` body). Plain
+ * settable fields (wire-deserialized input); `string?`/`Dictionary?` -> `| undefined`.
+ */
+class MeshDispatchRequest {
+    /** The target service's name (its key in the mesh registry). */
+    service;
+    /** The topic to invoke on the target service. */
+    topic;
+    /** Message headers to carry (optional). */
+    headers;
+    /** The serialized message body (optional). */
+    body;
+}
+exports.MeshDispatchRequest = MeshDispatchRequest;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Port of Benzene.Mesh.Dispatch - the opt-in, environment-gated `benzene:mesh:dispatch` handler that invokes ONE
+ * registered service's real handler with a caller-supplied payload (the direct-to-consumer test path).
+ * Refused in Production unless `MeshDispatchOptions.allowInProduction` is set. Ships the HTTP dispatcher
+ * (over an injectable `fetch`); other transports register their own `IMeshServiceDispatcher`.
+ */
+export * from './MeshDispatchOptions';
+export * from './MeshDispatchRequest';
+export * from './MeshDispatchEnvelope';
+export * from './IMeshDispatchEnvironment';
+export * from './IMeshServiceDispatcher';
+export * from './MeshDispatchGate';
+export * from './HttpMeshServiceDispatcher';
+export * from './MeshDispatchMessageHandler';
+export * from './Extensions';

package/dist/index.js

@@ -0,0 +1,31 @@
+"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 });
+/**
+ * Port of Benzene.Mesh.Dispatch - the opt-in, environment-gated `benzene:mesh:dispatch` handler that invokes ONE
+ * registered service's real handler with a caller-supplied payload (the direct-to-consumer test path).
+ * Refused in Production unless `MeshDispatchOptions.allowInProduction` is set. Ships the HTTP dispatcher
+ * (over an injectable `fetch`); other transports register their own `IMeshServiceDispatcher`.
+ */
+__exportStar(require("./MeshDispatchOptions"), exports);
+__exportStar(require("./MeshDispatchRequest"), exports);
+__exportStar(require("./MeshDispatchEnvelope"), exports);
+__exportStar(require("./IMeshDispatchEnvironment"), exports);
+__exportStar(require("./IMeshServiceDispatcher"), exports);
+__exportStar(require("./MeshDispatchGate"), exports);
+__exportStar(require("./HttpMeshServiceDispatcher"), exports);
+__exportStar(require("./MeshDispatchMessageHandler"), exports);
+__exportStar(require("./Extensions"), exports);

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@benzenejs/mesh-dispatch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.2",
+  "description": "TypeScript port of Benzene.Mesh.Dispatch",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@benzenejs/abstractions": "0.1.0-beta.2",
+    "@benzenejs/abstractions-message-handlers": "0.1.0-beta.2",
+    "@benzenejs/abstractions-middleware": "0.1.0-beta.2",
+    "@benzenejs/core-message-handlers": "0.1.0-beta.2",
+    "@benzenejs/core-messages": "0.1.0-beta.2",
+    "@benzenejs/mesh-contracts": "0.1.0-beta.2",
+    "@benzenejs/results": "0.1.0-beta.2"
+  },
+  "files": [
+    "dist"
+  ]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.