@benzenejs/mesh-fleet-aws-xray 0.0.0-stage → 0.1.0-beta.2

package/dist/Extensions.d.ts

@@ -0,0 +1,27 @@
+import { IBenzeneServiceContainer } from '@benzenejs/abstractions';
+import { XRayTraceSourceOptions } from './XRayTraceSourceOptions';
+/**
+ * Registers an {@link XRayTraceSource} as the {@link IMeshTraceSource} and composes it - with whatever
+ * `IMeshUsageSource`s are registered (e.g. a CloudWatch usage source) - into a
+ * `CompositeMeshFleetReadModel` serving {@link IMeshFleetReadModel}, so the whole fleet view (trace +
+ * correlation from X-Ray, topic stats from the usage feed, recent flows + anonymous services from X-Ray)
+ * answers on the AWS plane. Wire the read side with `useMessageHandlers(meshCollectorQueries)` and point the
+ * mesh UI's live Fleet plane at it with `useMeshUi(..., envelopeUrl: '/benzene/invoke')`; no
+ * `MeshCollectorStore` is needed - there is no push ingestion, only queries against X-Ray + the usage
+ * backend. C# extension method -> free function.
+ *
+ * Add a usage source separately for topic stats; without one the composite still serves
+ * traces/correlation/recent-flows/services and reports no topic stats (honest empty), rather than
+ * fabricating counts. Per-service and single-topic pages stay omitted (no descriptor feed on this plane).
+ *
+ * Divergence from the C# original: the C# registers a default `IAmazonXRay` in the container (unless one is
+ * already registered), the same pattern as `AddCloudWatchUsage`; this port has no ambient
+ * container-registered AWS client, so the `IMeshTraceSource` factory constructs `new XRayClient({})`
+ * directly - resolving region and credentials from the ambient AWS environment (on Lambda, the execution
+ * role), the same pattern as the `addSqs*` extensions.
+ *
+ * @param services The service container to register with.
+ * @param options Correlation + recent-flows tuning (lookback windows); defaults if omitted.
+ * @returns The service container for method chaining.
+ */
+export declare function addXRayFleetReadModel(services: IBenzeneServiceContainer, options?: XRayTraceSourceOptions): IBenzeneServiceContainer;

package/dist/Extensions.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addXRayFleetReadModel = addXRayFleetReadModel;
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.Extensions. */
+const client_xray_1 = require("@aws-sdk/client-xray");
+const mesh_collector_1 = require("@benzenejs/mesh-collector");
+const mesh_contracts_1 = require("@benzenejs/mesh-contracts");
+const XRayTraceSource_1 = require("./XRayTraceSource");
+const XRayTraceSourceOptions_1 = require("./XRayTraceSourceOptions");
+/**
+ * Registers an {@link XRayTraceSource} as the {@link IMeshTraceSource} and composes it - with whatever
+ * `IMeshUsageSource`s are registered (e.g. a CloudWatch usage source) - into a
+ * `CompositeMeshFleetReadModel` serving {@link IMeshFleetReadModel}, so the whole fleet view (trace +
+ * correlation from X-Ray, topic stats from the usage feed, recent flows + anonymous services from X-Ray)
+ * answers on the AWS plane. Wire the read side with `useMessageHandlers(meshCollectorQueries)` and point the
+ * mesh UI's live Fleet plane at it with `useMeshUi(..., envelopeUrl: '/benzene/invoke')`; no
+ * `MeshCollectorStore` is needed - there is no push ingestion, only queries against X-Ray + the usage
+ * backend. C# extension method -> free function.
+ *
+ * Add a usage source separately for topic stats; without one the composite still serves
+ * traces/correlation/recent-flows/services and reports no topic stats (honest empty), rather than
+ * fabricating counts. Per-service and single-topic pages stay omitted (no descriptor feed on this plane).
+ *
+ * Divergence from the C# original: the C# registers a default `IAmazonXRay` in the container (unless one is
+ * already registered), the same pattern as `AddCloudWatchUsage`; this port has no ambient
+ * container-registered AWS client, so the `IMeshTraceSource` factory constructs `new XRayClient({})`
+ * directly - resolving region and credentials from the ambient AWS environment (on Lambda, the execution
+ * role), the same pattern as the `addSqs*` extensions.
+ *
+ * @param services The service container to register with.
+ * @param options Correlation + recent-flows tuning (lookback windows); defaults if omitted.
+ * @returns The service container for method chaining.
+ */
+function addXRayFleetReadModel(services, options = new XRayTraceSourceOptions_1.XRayTraceSourceOptions()) {
+    services.addSingletonInstance(XRayTraceSourceOptions_1.XRayTraceSourceOptions, options);
+    services.addSingletonFactory(mesh_collector_1.IMeshTraceSource, (resolver) => new XRayTraceSource_1.XRayTraceSource(new client_xray_1.XRayClient({}), resolver.getService(XRayTraceSourceOptions_1.XRayTraceSourceOptions)));
+    services.addSingletonFactory(mesh_collector_1.IMeshFleetReadModel, (resolver) => new mesh_collector_1.CompositeMeshFleetReadModel(resolver.getService(mesh_collector_1.IMeshTraceSource), resolver.getServices(mesh_contracts_1.IMeshUsageSource)));
+    return services;
+}

package/dist/XRaySegmentMapper.d.ts

@@ -0,0 +1,27 @@
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRaySegmentMapper. */
+import { MeshTraceEvent } from '@benzenejs/mesh-wire';
+/**
+ * Maps the raw X-Ray segment documents of one trace (the JSON strings X-Ray returns from `BatchGetTraces`)
+ * into the mesh's {@link MeshTraceEvent} shape. Only nodes that carry a Benzene topic attribute become
+ * events - X-Ray traces mix in transport/AWS-SDK spans the mesh view has no place for, so this filters to
+ * the topic-bearing spans the pipeline stamps (`Benzene.Diagnostics.ActivityMiddlewareDecorator`; see
+ * `work/otel-fleet-adapter-scope.md`).
+ *
+ * A Benzene span's attributes may land in X-Ray as either `annotations` (keys sanitised to underscores -
+ * `benzene_topic`) or `metadata` (dotted keys preserved - `benzene.topic`, possibly nested under a namespace
+ * like `default`), depending on how the OTel->X-Ray exporter is configured. This reads both forms so the
+ * adapter works regardless of that choice. Segment/subsegment nesting gives parentage; the enclosing
+ * segment's `name` is the emitting service.
+ *
+ * `System.Text.Json.JsonDocument` -> `JSON.parse` + `unknown` type guards (mirroring `TempoTraceMapper`);
+ * `DateTimeOffset` -> epoch-ms `number`. A document that fails to parse is skipped (X-Ray traces are read
+ * best-effort), exactly as the C# catches `JsonException`.
+ */
+export declare const XRaySegmentMapper: {
+    /**
+     * Parse each segment document and emit one {@link MeshTraceEvent} per topic-bearing node, carrying the
+     * queried `meshTraceId` and ordered by start time. A document that fails to parse is skipped rather than
+     * failing the whole lookup. Returns an empty list when no node carried a Benzene topic.
+     */
+    readonly map: (meshTraceId: string, segmentDocuments: Iterable<string | undefined>) => MeshTraceEvent[];
+};

package/dist/XRaySegmentMapper.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XRaySegmentMapper = void 0;
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRaySegmentMapper. */
+const mesh_wire_1 = require("@benzenejs/mesh-wire");
+/**
+ * Maps the raw X-Ray segment documents of one trace (the JSON strings X-Ray returns from `BatchGetTraces`)
+ * into the mesh's {@link MeshTraceEvent} shape. Only nodes that carry a Benzene topic attribute become
+ * events - X-Ray traces mix in transport/AWS-SDK spans the mesh view has no place for, so this filters to
+ * the topic-bearing spans the pipeline stamps (`Benzene.Diagnostics.ActivityMiddlewareDecorator`; see
+ * `work/otel-fleet-adapter-scope.md`).
+ *
+ * A Benzene span's attributes may land in X-Ray as either `annotations` (keys sanitised to underscores -
+ * `benzene_topic`) or `metadata` (dotted keys preserved - `benzene.topic`, possibly nested under a namespace
+ * like `default`), depending on how the OTel->X-Ray exporter is configured. This reads both forms so the
+ * adapter works regardless of that choice. Segment/subsegment nesting gives parentage; the enclosing
+ * segment's `name` is the emitting service.
+ *
+ * `System.Text.Json.JsonDocument` -> `JSON.parse` + `unknown` type guards (mirroring `TempoTraceMapper`);
+ * `DateTimeOffset` -> epoch-ms `number`. A document that fails to parse is skipped (X-Ray traces are read
+ * best-effort), exactly as the C# catches `JsonException`.
+ */
+exports.XRaySegmentMapper = {
+    /**
+     * Parse each segment document and emit one {@link MeshTraceEvent} per topic-bearing node, carrying the
+     * queried `meshTraceId` and ordered by start time. A document that fails to parse is skipped rather than
+     * failing the whole lookup. Returns an empty list when no node carried a Benzene topic.
+     */
+    map(meshTraceId, segmentDocuments) {
+        const events = [];
+        for (const document of segmentDocuments) {
+            if (document === undefined || document.trim().length === 0) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(document);
+            }
+            catch {
+                continue;
+            }
+            if (!isObject(parsed)) {
+                continue;
+            }
+            const service = tryGetString(parsed, 'name');
+            walk(meshTraceId, parsed, service, events);
+        }
+        events.sort((a, b) => a.startedAt - b.startedAt);
+        return events;
+    },
+};
+/**
+ * Recursively walk a segment/subsegment node, emitting an event for any topic-bearing node and descending
+ * into its subsegments.
+ */
+function walk(meshTraceId, node, service, events) {
+    const topic = readBenzene(node, 'topic');
+    if (topic !== undefined && topic.length > 0) {
+        const event = new mesh_wire_1.MeshTraceEvent();
+        event.traceId = meshTraceId;
+        event.spanId = tryGetString(node, 'id') ?? '';
+        event.parentSpanId = tryGetString(node, 'parent_id');
+        // Prefer the Benzene service name the pipeline stamps (benzene.service) over the X-Ray segment name: on
+        // Lambda the segment is named by ADOT after the handler (e.g. "ApiGatewayLambdaHandler"), not the
+        // service, so the segment name is only a fallback for a span that predates the tag.
+        event.service = readBenzene(node, 'service') ?? service;
+        event.topic = topic;
+        event.topicVersion = readBenzene(node, 'version');
+        event.status = readBenzene(node, 'status') ?? '';
+        // The failure's WHY (spec §3 exceptionType): the thrown exception's type name, stamped by the pipeline
+        // on the same topic-bearing span as benzene.status. Undefined for non-exception failures or spans
+        // predating the tag.
+        event.exceptionType = readBenzene(node, 'exception.type');
+        event.correlationId = readBenzene(node, 'correlation-id') ?? readBenzene(node, 'correlationId');
+        event.startedAt = readStartedAt(node);
+        event.durationMs = readDurationMs(node);
+        events.push(event);
+    }
+    const subsegments = node['subsegments'];
+    if (isArray(subsegments)) {
+        for (const sub of subsegments) {
+            if (isObject(sub)) {
+                // Keep the enclosing segment's name as the service: subsegments are the same service's internal
+                // spans, not a new service boundary (which X-Ray would model as its own segment).
+                walk(meshTraceId, sub, service, events);
+            }
+        }
+    }
+}
+/**
+ * Read a `benzene.<name>` attribute from either the node's annotations (underscore key) or its metadata
+ * (dotted key, at the top level or one namespace deep).
+ */
+function readBenzene(node, name) {
+    const underscoreKey = 'benzene_' + name.replace(/-/g, '_').replace(/\./g, '_');
+    const dottedKey = 'benzene.' + name;
+    const annotations = node['annotations'];
+    if (isObject(annotations)) {
+        const fromAnnotation = tryReadValue(annotations, underscoreKey);
+        if (fromAnnotation !== undefined) {
+            return fromAnnotation;
+        }
+    }
+    const metadata = node['metadata'];
+    if (isObject(metadata)) {
+        const fromMetadata = tryReadValue(metadata, dottedKey);
+        if (fromMetadata !== undefined) {
+            return fromMetadata;
+        }
+        // OTel->X-Ray nests span attributes one namespace deep (default "default").
+        for (const value of Object.values(metadata)) {
+            if (isObject(value)) {
+                const fromNamespaced = tryReadValue(value, dottedKey);
+                if (fromNamespaced !== undefined) {
+                    return fromNamespaced;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/** Read a scalar property as text, coercing number/boolean kinds; `undefined` when absent or a non-scalar. */
+function tryReadValue(obj, key) {
+    const value = obj[key];
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (value === true) {
+        return 'true';
+    }
+    if (value === false) {
+        return 'false';
+    }
+    return undefined;
+}
+/** X-Ray `start_time` is epoch seconds as a double (sub-second fraction preserved). */
+function readStartedAt(node) {
+    const startSeconds = tryGetDouble(node, 'start_time');
+    return startSeconds === undefined ? 0 : Math.floor(startSeconds * 1000);
+}
+function readDurationMs(node) {
+    const start = tryGetDouble(node, 'start_time');
+    const end = tryGetDouble(node, 'end_time');
+    return start !== undefined && end !== undefined ? (end - start) * 1000 : 0;
+}
+function tryGetString(node, name) {
+    const value = node[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function tryGetDouble(node, name) {
+    const value = node[name];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    // Some exporters serialise the epoch as a string; accept that too.
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+    return Array.isArray(value);
+}

package/dist/XRayTraceSource.d.ts

@@ -0,0 +1,60 @@
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRayTraceSource. */
+import { XRayClient } from '@aws-sdk/client-xray';
+import { CorrelationView, IMeshTraceSource, MeshTimeRange, TraceSummary, TraceView } from '@benzenejs/mesh-collector';
+import { XRayTraceSourceOptions } from './XRayTraceSourceOptions';
+/**
+ * An {@link IMeshTraceSource} that answers `benzene:mesh:query:trace` and `benzene:mesh:query:correlation` from AWS X-Ray:
+ * it fetches a trace's segments with `BatchGetTraces` and maps the topic-bearing spans into a
+ * {@link TraceView} (see {@link XRaySegmentMapper}), and finds a business correlation id's flows with
+ * `GetTraceSummaries` filtered on the correlation-id annotation. The AWS realisation of the trace-backed
+ * fleet reader scoped in `work/otel-fleet-adapter-scope.md`, reusing the same `CompositeMeshFleetReadModel`,
+ * handlers, and UI as the Tempo/Jaeger adapters - no push collector required.
+ *
+ * Trace stats and service health are deliberately not sourced here (see {@link IMeshTraceSource}); X-Ray
+ * traces are sampled, so counts would be biased, and X-Ray has no heartbeat feed. Those compose from an
+ * `IMeshUsageSource` (CloudWatch) and the heartbeat plane in later increments.
+ *
+ * `IAmazonXRay` -> the `@aws-sdk/client-xray` `XRayClient` (`_xray.BatchGetTracesAsync(req)` ->
+ * `xray.send(new BatchGetTracesCommand(input))`); the v3 SDK uses PascalCase shape members, so the request
+ * and response shapes map almost 1:1 to the C#. C# two constructors (defaulted / explicit options) -> one
+ * constructor with a defaulted `options`. `CancellationToken` -> optional `AbortSignal` (threaded to `send`
+ * as `{ abortSignal }`); `DateTimeOffset` -> epoch-ms `number` (X-Ray's `StartTime`/`EndTime` are JS
+ * `Date`); `Task.WhenAll` -> `Promise.all`; `StringComparer.Ordinal` -> {@link ordinalCompare}.
+ */
+export declare class XRayTraceSource implements IMeshTraceSource {
+    private readonly xray;
+    private readonly options;
+    /**
+     * Creates the source over an X-Ray client (region/credentials come from the client) with optional tuning.
+     * @param xray The `@aws-sdk/client-xray` client the source queries.
+     * @param options Correlation + recent-flows tuning (lookback windows, enrichment cap); defaults if omitted.
+     */
+    constructor(xray: XRayClient, options?: XRayTraceSourceOptions);
+    getTraceAsync(traceId: string, cancellationToken?: AbortSignal): Promise<TraceView | undefined>;
+    getCorrelationAsync(correlationId: string, range?: MeshTimeRange, cancellationToken?: AbortSignal): Promise<CorrelationView | undefined>;
+    getRecentFlowsAsync(limit?: number, range?: MeshTimeRange, cancellationToken?: AbortSignal): Promise<readonly TraceSummary[]>;
+    /**
+     * Enrich the chosen summaries with real span data by batching {@link BatchGetTracesMax} ids per
+     * `BatchGetTraces` call (parallel, per-batch fetch-isolation). A trace that maps to Benzene events becomes
+     * an enriched row (benzene.service names, ms start, real span count); a trace with no Benzene span or a
+     * failed batch keeps its summary-plane row. Skips all fetches when enrichment is off
+     * ({@link XRayTraceSourceOptions.recentFlowsServiceEnrichmentMax} = 0).
+     */
+    private enrichRecentFlows;
+    /**
+     * Fetch a <=5-id batch from X-Ray and map each returned trace's segments to events. A failed batch leaves
+     * its rows on the summary plane (fetch isolation), never the whole list.
+     */
+    private fetchBatch;
+    /**
+     * Fetch the given trace ids from X-Ray and map the returned segments to events under one mesh trace id (a
+     * single trace's lookup).
+     */
+    private fetchEvents;
+    /**
+     * Resolve a requested {@link MeshTimeRange} to X-Ray's `[start,end]`, falling back to `now - fallbackMs`
+     * .. `now` when no window was requested (today's behavior). X-Ray's `GetTraceSummaries` needs a bounded
+     * range either way.
+     */
+    private resolveWindow;
+}

package/dist/XRayTraceSource.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XRayTraceSource = void 0;
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRayTraceSource. */
+const client_xray_1 = require("@aws-sdk/client-xray");
+const mesh_collector_1 = require("@benzenejs/mesh-collector");
+const XRaySegmentMapper_1 = require("./XRaySegmentMapper");
+const XRayTraceSourceOptions_1 = require("./XRayTraceSourceOptions");
+// X-Ray's BatchGetTraces accepts at most 5 trace ids per call.
+const BatchGetTracesMax = 5;
+/**
+ * An {@link IMeshTraceSource} that answers `benzene:mesh:query:trace` and `benzene:mesh:query:correlation` from AWS X-Ray:
+ * it fetches a trace's segments with `BatchGetTraces` and maps the topic-bearing spans into a
+ * {@link TraceView} (see {@link XRaySegmentMapper}), and finds a business correlation id's flows with
+ * `GetTraceSummaries` filtered on the correlation-id annotation. The AWS realisation of the trace-backed
+ * fleet reader scoped in `work/otel-fleet-adapter-scope.md`, reusing the same `CompositeMeshFleetReadModel`,
+ * handlers, and UI as the Tempo/Jaeger adapters - no push collector required.
+ *
+ * Trace stats and service health are deliberately not sourced here (see {@link IMeshTraceSource}); X-Ray
+ * traces are sampled, so counts would be biased, and X-Ray has no heartbeat feed. Those compose from an
+ * `IMeshUsageSource` (CloudWatch) and the heartbeat plane in later increments.
+ *
+ * `IAmazonXRay` -> the `@aws-sdk/client-xray` `XRayClient` (`_xray.BatchGetTracesAsync(req)` ->
+ * `xray.send(new BatchGetTracesCommand(input))`); the v3 SDK uses PascalCase shape members, so the request
+ * and response shapes map almost 1:1 to the C#. C# two constructors (defaulted / explicit options) -> one
+ * constructor with a defaulted `options`. `CancellationToken` -> optional `AbortSignal` (threaded to `send`
+ * as `{ abortSignal }`); `DateTimeOffset` -> epoch-ms `number` (X-Ray's `StartTime`/`EndTime` are JS
+ * `Date`); `Task.WhenAll` -> `Promise.all`; `StringComparer.Ordinal` -> {@link ordinalCompare}.
+ */
+class XRayTraceSource {
+    xray;
+    options;
+    /**
+     * Creates the source over an X-Ray client (region/credentials come from the client) with optional tuning.
+     * @param xray The `@aws-sdk/client-xray` client the source queries.
+     * @param options Correlation + recent-flows tuning (lookback windows, enrichment cap); defaults if omitted.
+     */
+    constructor(xray, options = new XRayTraceSourceOptions_1.XRayTraceSourceOptions()) {
+        this.xray = xray;
+        this.options = options;
+    }
+    async getTraceAsync(traceId, cancellationToken) {
+        if (traceId.length === 0) {
+            return undefined;
+        }
+        const events = await this.fetchEvents([traceId], traceId, cancellationToken);
+        // Undefined (not empty) when X-Ray has no such trace, or a real trace that carried no Benzene
+        // topic-bearing span - so the query handler answers NotFound, not an empty waterfall.
+        if (events.length === 0) {
+            return undefined;
+        }
+        const view = new mesh_collector_1.TraceView();
+        view.traceId = traceId;
+        view.events = events;
+        return view;
+    }
+    async getCorrelationAsync(correlationId, range, cancellationToken) {
+        if (correlationId.length === 0) {
+            return undefined;
+        }
+        const window = this.resolveWindow(range, this.options.correlationLookbackMs);
+        // benzene.correlation-id lands in X-Ray as the underscore-sanitised annotation key; only annotations are
+        // filterable (see work/otel-fleet-adapter-scope.md §6b).
+        const filter = `annotation.benzene_correlation_id = "${escape(correlationId)}"`;
+        const traceIds = [];
+        let nextToken;
+        do {
+            const response = await this.xray.send(new client_xray_1.GetTraceSummariesCommand({
+                StartTime: new Date(window.start),
+                EndTime: new Date(window.end),
+                FilterExpression: filter,
+                NextToken: nextToken,
+            }), abortOptions(cancellationToken));
+            for (const summary of response.TraceSummaries ?? []) {
+                if (summary.Id !== undefined && summary.Id.length > 0) {
+                    traceIds.push(summary.Id);
+                }
+            }
+            nextToken = response.NextToken !== undefined && response.NextToken.length > 0 ? response.NextToken : undefined;
+        } while (nextToken !== undefined);
+        if (traceIds.length === 0) {
+            return undefined;
+        }
+        const traces = [];
+        for (const batch of chunk(traceIds, BatchGetTracesMax)) {
+            const response = await this.xray.send(new client_xray_1.BatchGetTracesCommand({ TraceIds: batch }), abortOptions(cancellationToken));
+            for (const trace of response.Traces ?? []) {
+                const segments = trace.Segments;
+                if (segments === undefined || segments.length === 0 || trace.Id === undefined || trace.Id.length === 0) {
+                    continue;
+                }
+                const events = XRaySegmentMapper_1.XRaySegmentMapper.map(trace.Id, segments.map((s) => s.Document));
+                if (events.length > 0) {
+                    const view = new mesh_collector_1.TraceView();
+                    view.traceId = trace.Id;
+                    view.events = events;
+                    traces.push(view);
+                }
+            }
+        }
+        if (traces.length === 0) {
+            return undefined;
+        }
+        // Earliest-first, the same ordering the in-memory collector's correlation view uses so the UI renders
+        // both identically.
+        traces.sort((a, b) => earliestStart(a) - earliestStart(b));
+        const result = new mesh_collector_1.CorrelationView();
+        result.correlationId = correlationId;
+        result.traces = traces;
+        return result;
+    }
+    async getRecentFlowsAsync(limit = 20, range, cancellationToken) {
+        if (limit <= 0) {
+            return [];
+        }
+        const window = this.resolveWindow(range, this.options.recentFlowsLookbackMs);
+        const summaries = [];
+        let nextToken;
+        do {
+            const response = await this.xray.send(new client_xray_1.GetTraceSummariesCommand({
+                StartTime: new Date(window.start),
+                EndTime: new Date(window.end),
+                NextToken: nextToken,
+            }), abortOptions(cancellationToken));
+            if (response.TraceSummaries !== undefined) {
+                summaries.push(...response.TraceSummaries);
+            }
+            nextToken = response.NextToken !== undefined && response.NextToken.length > 0 ? response.NextToken : undefined;
+            // Stop once we have comfortably more than the cap to sort a newest-first top-N from; the window, not
+            // exhaustive paging, bounds a "recent flows" list.
+        } while (nextToken !== undefined && summaries.length < limit * 4);
+        // Select the newest N by the trace-id epoch (second-granularity, but enough to pick the right ~20), then
+        // enrich those rows below. Ordering within a second is refined by the enriched millisecond start; the
+        // final sort applies a stable trace-id tiebreaker so both planes are deterministic.
+        const top = [...summaries]
+            .sort((a, b) => {
+            const byEpoch = parseTraceStart(b.Id) - parseTraceStart(a.Id);
+            return byEpoch !== 0 ? byEpoch : ordinalCompare(b.Id ?? '', a.Id ?? '');
+        })
+            .slice(0, limit);
+        const rows = await this.enrichRecentFlows(top, limit, cancellationToken);
+        return rows.sort((a, b) => {
+            const byStart = b.startedAt - a.startedAt;
+            return byStart !== 0 ? byStart : ordinalCompare(b.traceId, a.traceId);
+        });
+    }
+    /**
+     * Enrich the chosen summaries with real span data by batching {@link BatchGetTracesMax} ids per
+     * `BatchGetTraces` call (parallel, per-batch fetch-isolation). A trace that maps to Benzene events becomes
+     * an enriched row (benzene.service names, ms start, real span count); a trace with no Benzene span or a
+     * failed batch keeps its summary-plane row. Skips all fetches when enrichment is off
+     * ({@link XRayTraceSourceOptions.recentFlowsServiceEnrichmentMax} = 0).
+     */
+    async enrichRecentFlows(summaries, limit, cancellationToken) {
+        const enrichMax = Math.min(Math.max(this.options.recentFlowsServiceEnrichmentMax, 0), limit);
+        if (enrichMax === 0) {
+            return summaries.map(toSummaryPlaneRow);
+        }
+        // Which trace ids to enrich (the first enrichMax that have an id); the rest stay summary-plane.
+        const toEnrich = summaries
+            .filter((s) => s.Id !== undefined && s.Id.length > 0)
+            .slice(0, enrichMax)
+            .map((s) => s.Id);
+        const mapped = new Map();
+        const batches = await Promise.all(chunk(toEnrich, BatchGetTracesMax).map((ids) => this.fetchBatch(ids, cancellationToken)));
+        for (const batch of batches) {
+            for (const [id, events] of batch) {
+                mapped.set(id, events);
+            }
+        }
+        // Enriched row where the trace mapped to at least one Benzene event; summary-plane fallback otherwise.
+        return summaries.map((s) => {
+            const events = s.Id !== undefined ? mapped.get(s.Id) : undefined;
+            return events !== undefined && events.length > 0 ? enrichedRow(s, events) : toSummaryPlaneRow(s);
+        });
+    }
+    /**
+     * Fetch a <=5-id batch from X-Ray and map each returned trace's segments to events. A failed batch leaves
+     * its rows on the summary plane (fetch isolation), never the whole list.
+     */
+    async fetchBatch(ids, cancellationToken) {
+        const result = new Map();
+        try {
+            const response = await this.xray.send(new client_xray_1.BatchGetTracesCommand({ TraceIds: ids }), abortOptions(cancellationToken));
+            for (const trace of response.Traces ?? []) {
+                const segments = trace.Segments;
+                if (segments === undefined || segments.length === 0 || trace.Id === undefined || trace.Id.length === 0) {
+                    continue;
+                }
+                result.set(trace.Id, XRaySegmentMapper_1.XRaySegmentMapper.map(trace.Id, segments.map((s) => s.Document)));
+            }
+        }
+        catch {
+            // Fetch isolation: a failed batch leaves its <=5 rows on the summary plane, never the whole list.
+        }
+        return result;
+    }
+    /**
+     * Fetch the given trace ids from X-Ray and map the returned segments to events under one mesh trace id (a
+     * single trace's lookup).
+     */
+    async fetchEvents(traceIds, meshTraceId, cancellationToken) {
+        const response = await this.xray.send(new client_xray_1.BatchGetTracesCommand({ TraceIds: traceIds }), abortOptions(cancellationToken));
+        // X-Ray returns an unknown id in UnprocessedTraceIds (not Traces), so an unknown trace yields no segments
+        // here -> an empty event list -> a null view upstream.
+        const documents = [];
+        for (const trace of response.Traces ?? []) {
+            const segments = trace.Segments;
+            if (segments !== undefined && segments.length > 0) {
+                for (const segment of segments) {
+                    documents.push(segment.Document);
+                }
+            }
+        }
+        return XRaySegmentMapper_1.XRaySegmentMapper.map(meshTraceId, documents);
+    }
+    /**
+     * Resolve a requested {@link MeshTimeRange} to X-Ray's `[start,end]`, falling back to `now - fallbackMs`
+     * .. `now` when no window was requested (today's behavior). X-Ray's `GetTraceSummaries` needs a bounded
+     * range either way.
+     */
+    resolveWindow(range, fallbackMs) {
+        const resolved = mesh_collector_1.MeshTimeRangeResolver.resolve(range, Date.now());
+        if (resolved !== undefined) {
+            return { start: resolved.from, end: resolved.to };
+        }
+        const end = Date.now();
+        return { start: end - fallbackMs, end };
+    }
+}
+exports.XRayTraceSource = XRayTraceSource;
+/**
+ * An enriched recent-flows row: real service names (benzene.service, from the mapped events), the earliest
+ * event's millisecond start, and the real span count. Keeps the summary's authoritative error flag
+ * (`HasError`/`HasFault`) and duration.
+ */
+function enrichedRow(summary, events) {
+    const row = new mesh_collector_1.TraceSummary();
+    row.traceId = summary.Id ?? '';
+    // X-Ray Duration is in seconds; the mesh carries milliseconds.
+    row.durationMs = (summary.Duration ?? 0) * 1000;
+    row.failed = (summary.HasError ?? false) || (summary.HasFault ?? false);
+    row.services = [
+        ...new Set(events.map((e) => e.service).filter((name) => name !== undefined && name.length > 0)),
+    ].sort(ordinalCompare);
+    row.startedAt = Math.min(...events.map((e) => e.startedAt));
+    row.events = events.length;
+    // The flow's entry topic: the earliest mapped event's (map returns events in start order).
+    row.topic = events[0].topic;
+    // How the flow ended (mesh.md §4), from the mapped events' benzene.status. `failed` is X-Ray's own error
+    // flag here, so when it and the events disagree no event decides the flow and the status is omitted.
+    row.status = (0, mesh_collector_1.flowStatus)(events, row.failed);
+    return row;
+}
+function toSummaryPlaneRow(summary) {
+    const row = new mesh_collector_1.TraceSummary();
+    row.traceId = summary.Id ?? '';
+    // X-Ray Duration is in seconds; the mesh carries milliseconds.
+    row.durationMs = (summary.Duration ?? 0) * 1000;
+    row.failed = (summary.HasError ?? false) || (summary.HasFault ?? false);
+    row.services = [
+        ...new Set((summary.ServiceIds ?? [])
+            .map((s) => s.Name)
+            .filter((name) => name !== undefined && name.length > 0)),
+    ];
+    row.startedAt = parseTraceStart(summary.Id);
+    row.events = 0; // X-Ray summaries carry no span count; the drill-in trace has it.
+    // No `status`: a summary-plane row has no Benzene spans to read it from (mesh.md §4 - omitted when unknown).
+    return row;
+}
+/**
+ * An X-Ray trace id is `1-{8 hex epoch seconds}-{24 hex}`; the middle group is the trace's start time. Falls
+ * back to `0` (the epoch, the TS analog of C# `DateTimeOffset.MinValue` used only for ordering) for an
+ * unparseable id.
+ */
+function parseTraceStart(traceId) {
+    if (traceId !== undefined) {
+        const parts = traceId.split('-');
+        if (parts.length >= 2 && /^[0-9a-fA-F]{1,15}$/.test(parts[1])) {
+            const epoch = parseInt(parts[1], 16);
+            if (!Number.isNaN(epoch)) {
+                return epoch * 1000;
+            }
+        }
+    }
+    return 0;
+}
+function earliestStart(trace) {
+    return trace.events.length === 0 ? Number.MAX_SAFE_INTEGER : Math.min(...trace.events.map((e) => e.startedAt));
+}
+// X-Ray filter-expression string literals are double-quoted; escape backslashes and quotes so a correlation
+// id can't break out of the literal.
+function escape(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function chunk(items, size) {
+    const result = [];
+    for (let i = 0; i < items.length; i += size) {
+        result.push(items.slice(i, i + size));
+    }
+    return result;
+}
+function ordinalCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** Thread the optional `AbortSignal` to the SDK's `send` as its `HttpHandlerOptions`, or omit it. */
+function abortOptions(cancellationToken) {
+    return cancellationToken !== undefined ? { abortSignal: cancellationToken } : undefined;
+}

package/dist/XRayTraceSourceOptions.d.ts

@@ -0,0 +1,42 @@
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRayTraceSourceOptions. */
+/** Default `correlationLookbackMs`: 24 hours, in milliseconds (`TimeSpan` -> millisecond `number`). */
+export declare const DefaultCorrelationLookbackMs: number;
+/** Default `recentFlowsLookbackMs`: 1 hour, in milliseconds (`TimeSpan` -> millisecond `number`). */
+export declare const DefaultRecentFlowsLookbackMs: number;
+/** Default `recentFlowsServiceEnrichmentMax`: the fleet cap (20 rows). */
+export declare const DefaultRecentFlowsServiceEnrichmentMax = 20;
+/**
+ * Tuning for {@link XRayTraceSource}. Only correlation search and recent-flows enrichment need these - a
+ * trace lookup is by id (`BatchGetTraces`, no window). X-Ray's `GetTraceSummaries` requires a time range, so
+ * a correlation/recent-flows lookup searches a bounded window for matching traces.
+ *
+ * `TimeSpan` -> millisecond `number` (`correlationLookbackMs`/`recentFlowsLookbackMs`). The C# `init`
+ * properties -> plain mutable fields set after construction (`new XRayTraceSourceOptions()` then assign),
+ * since TypeScript object-initializer syntax has no `init`-only equivalent. Unlike the Tempo/Jaeger options
+ * there is no endpoint URL: the X-Ray SDK client resolves region/credentials from the ambient AWS
+ * environment, so the source takes the client, not a URL.
+ */
+export declare class XRayTraceSourceOptions {
+    /**
+     * How far back a `benzene:mesh:query:correlation` search scans X-Ray for matching traces (ms). Default 24 hours -
+     * a business correlation id (a ticket/log id) is typically chased soon after the event, and X-Ray retains
+     * traces for 30 days so a longer window is available if you widen it.
+     */
+    correlationLookbackMs: number;
+    /**
+     * How far back the fleet view's recent-flows list scans X-Ray (ms). Default 1 hour - the fleet view wants
+     * the latest activity, not history; kept separate from {@link correlationLookbackMs} because "what's
+     * flowing now" is a much shorter horizon than "find the trace(s) for this ticket".
+     */
+    recentFlowsLookbackMs: number;
+    /**
+     * How many of the recent-flows rows to enrich with real span data via a bounded `BatchGetTraces` (X-Ray
+     * allows 5 ids/call, so 20 -> <=4 calls). Enrichment reads the pipeline-stamped `benzene.service` as each
+     * row's service names (instead of X-Ray's own `ServiceIds`, which on Lambda are infra/handler names like
+     * `ApiGatewayLambdaHandler`), the mapped events' real millisecond start time (instead of the
+     * second-granularity trace-id epoch), and the real span count. Default 20 (= the fleet cap); a row whose
+     * trace can't be fetched or that carries no Benzene span falls back to the summary plane per-row. Set to
+     * `0` to opt out entirely (pure-summary behavior: `ServiceIds` names, id-epoch ordering, `events = 0`).
+     */
+    recentFlowsServiceEnrichmentMax: number;
+}

package/dist/XRayTraceSourceOptions.js

@@ -0,0 +1,46 @@
+"use strict";
+/** Port of Benzene.Mesh.Fleet.Aws.XRay.XRayTraceSourceOptions. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XRayTraceSourceOptions = exports.DefaultRecentFlowsServiceEnrichmentMax = exports.DefaultRecentFlowsLookbackMs = exports.DefaultCorrelationLookbackMs = void 0;
+/** Default `correlationLookbackMs`: 24 hours, in milliseconds (`TimeSpan` -> millisecond `number`). */
+exports.DefaultCorrelationLookbackMs = 24 * 60 * 60 * 1000;
+/** Default `recentFlowsLookbackMs`: 1 hour, in milliseconds (`TimeSpan` -> millisecond `number`). */
+exports.DefaultRecentFlowsLookbackMs = 60 * 60 * 1000;
+/** Default `recentFlowsServiceEnrichmentMax`: the fleet cap (20 rows). */
+exports.DefaultRecentFlowsServiceEnrichmentMax = 20;
+/**
+ * Tuning for {@link XRayTraceSource}. Only correlation search and recent-flows enrichment need these - a
+ * trace lookup is by id (`BatchGetTraces`, no window). X-Ray's `GetTraceSummaries` requires a time range, so
+ * a correlation/recent-flows lookup searches a bounded window for matching traces.
+ *
+ * `TimeSpan` -> millisecond `number` (`correlationLookbackMs`/`recentFlowsLookbackMs`). The C# `init`
+ * properties -> plain mutable fields set after construction (`new XRayTraceSourceOptions()` then assign),
+ * since TypeScript object-initializer syntax has no `init`-only equivalent. Unlike the Tempo/Jaeger options
+ * there is no endpoint URL: the X-Ray SDK client resolves region/credentials from the ambient AWS
+ * environment, so the source takes the client, not a URL.
+ */
+class XRayTraceSourceOptions {
+    /**
+     * How far back a `benzene:mesh:query:correlation` search scans X-Ray for matching traces (ms). Default 24 hours -
+     * a business correlation id (a ticket/log id) is typically chased soon after the event, and X-Ray retains
+     * traces for 30 days so a longer window is available if you widen it.
+     */
+    correlationLookbackMs = exports.DefaultCorrelationLookbackMs;
+    /**
+     * How far back the fleet view's recent-flows list scans X-Ray (ms). Default 1 hour - the fleet view wants
+     * the latest activity, not history; kept separate from {@link correlationLookbackMs} because "what's
+     * flowing now" is a much shorter horizon than "find the trace(s) for this ticket".
+     */
+    recentFlowsLookbackMs = exports.DefaultRecentFlowsLookbackMs;
+    /**
+     * How many of the recent-flows rows to enrich with real span data via a bounded `BatchGetTraces` (X-Ray
+     * allows 5 ids/call, so 20 -> <=4 calls). Enrichment reads the pipeline-stamped `benzene.service` as each
+     * row's service names (instead of X-Ray's own `ServiceIds`, which on Lambda are infra/handler names like
+     * `ApiGatewayLambdaHandler`), the mapped events' real millisecond start time (instead of the
+     * second-granularity trace-id epoch), and the real span count. Default 20 (= the fleet cap); a row whose
+     * trace can't be fetched or that carries no Benzene span falls back to the summary plane per-row. Set to
+     * `0` to opt out entirely (pure-summary behavior: `ServiceIds` names, id-epoch ordering, `events = 0`).
+     */
+    recentFlowsServiceEnrichmentMax = exports.DefaultRecentFlowsServiceEnrichmentMax;
+}
+exports.XRayTraceSourceOptions = XRayTraceSourceOptions;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Port of Benzene.Mesh.Fleet.Aws.XRay - the AWS realisation of the trace-backed fleet reader (alongside
+ * `@benzenejs/mesh-fleet-tempo` and `@benzenejs/mesh-fleet-jaeger`): it answers the mesh's `benzene:mesh:query:trace`,
+ * `benzene:mesh:query:correlation`, and the fleet view's recent-flows from **AWS X-Ray**, reusing the same
+ * `CompositeMeshFleetReadModel`, query handlers, and mesh UI - a backend on the `IMeshTraceSource` seam with
+ * zero upstream change.
+ *
+ * `XRayTraceSource` implements `IMeshTraceSource` over the X-Ray SDK (`BatchGetTraces` by id,
+ * `GetTraceSummaries` for correlation/recent-flows); `XRaySegmentMapper` maps X-Ray's segment-document JSON
+ * (annotations with underscore keys or metadata with dotted keys, possibly namespaced) into the mesh
+ * `MeshTraceEvent` shape. `addXRayFleetReadModel` wires the source + `CompositeMeshFleetReadModel`.
+ *
+ * Divergences from the C# original (see also each file's header):
+ * - `IAmazonXRay` -> the `@aws-sdk/client-xray` `XRayClient`. `_xray.BatchGetTracesAsync(req)` /
+ *   `_xray.GetTraceSummariesAsync(req)` -> `xray.send(new BatchGetTracesCommand(input))` /
+ *   `xray.send(new GetTraceSummariesCommand(input))`. The v3 SDK uses PascalCase shape members
+ *   (`TraceIds`/`Traces`/`Segments`/`Document`/`TraceSummaries`/`NextToken`/`Duration`/`HasError`/…), so the
+ *   request/response shapes map almost 1:1 to the C#; `StartTime`/`EndTime` are JS `Date`.
+ * - C# two constructors (`(IAmazonXRay)` defaulting options, `(IAmazonXRay, options)`) -> one constructor
+ *   `(xray, options = new XRayTraceSourceOptions())`.
+ * - `System.Text.Json.JsonDocument` -> `JSON.parse` + `unknown` type guards; `DateTimeOffset` -> epoch-ms
+ *   `number`; an unparseable trace-id epoch falls back to `0` (the epoch, the ordering analog of C#
+ *   `DateTimeOffset.MinValue`). `CancellationToken` -> optional `AbortSignal` (threaded to `send` as
+ *   `{ abortSignal }`); `Task.WhenAll` -> `Promise.all`; `StringComparer.Ordinal` -> an ordinal compare.
+ * - `addXRayFleetReadModel` constructs `new XRayClient({})` inside the `IMeshTraceSource` factory rather than
+ *   resolving a container-registered `IAmazonXRay` (there is no ambient AWS client token in the TS DI), the
+ *   same pattern as the `addSqs*` extensions.
+ * - Unlike the Tempo/Jaeger ports, `MeshTraceEvent.exceptionType` IS carried here: this port adds the
+ *   `exceptionType` field to `@benzenejs/mesh-wire`'s `MeshTraceEvent` (it was missing from the snapshot), and
+ *   the mapper reads `benzene.exception.type` into it (spec §3 "the failure's WHY").
+ */
+export * from './XRayTraceSourceOptions';
+export * from './XRaySegmentMapper';
+export * from './XRayTraceSource';
+export * from './Extensions';

package/dist/index.js

@@ -0,0 +1,51 @@
+"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.Fleet.Aws.XRay - the AWS realisation of the trace-backed fleet reader (alongside
+ * `@benzenejs/mesh-fleet-tempo` and `@benzenejs/mesh-fleet-jaeger`): it answers the mesh's `benzene:mesh:query:trace`,
+ * `benzene:mesh:query:correlation`, and the fleet view's recent-flows from **AWS X-Ray**, reusing the same
+ * `CompositeMeshFleetReadModel`, query handlers, and mesh UI - a backend on the `IMeshTraceSource` seam with
+ * zero upstream change.
+ *
+ * `XRayTraceSource` implements `IMeshTraceSource` over the X-Ray SDK (`BatchGetTraces` by id,
+ * `GetTraceSummaries` for correlation/recent-flows); `XRaySegmentMapper` maps X-Ray's segment-document JSON
+ * (annotations with underscore keys or metadata with dotted keys, possibly namespaced) into the mesh
+ * `MeshTraceEvent` shape. `addXRayFleetReadModel` wires the source + `CompositeMeshFleetReadModel`.
+ *
+ * Divergences from the C# original (see also each file's header):
+ * - `IAmazonXRay` -> the `@aws-sdk/client-xray` `XRayClient`. `_xray.BatchGetTracesAsync(req)` /
+ *   `_xray.GetTraceSummariesAsync(req)` -> `xray.send(new BatchGetTracesCommand(input))` /
+ *   `xray.send(new GetTraceSummariesCommand(input))`. The v3 SDK uses PascalCase shape members
+ *   (`TraceIds`/`Traces`/`Segments`/`Document`/`TraceSummaries`/`NextToken`/`Duration`/`HasError`/…), so the
+ *   request/response shapes map almost 1:1 to the C#; `StartTime`/`EndTime` are JS `Date`.
+ * - C# two constructors (`(IAmazonXRay)` defaulting options, `(IAmazonXRay, options)`) -> one constructor
+ *   `(xray, options = new XRayTraceSourceOptions())`.
+ * - `System.Text.Json.JsonDocument` -> `JSON.parse` + `unknown` type guards; `DateTimeOffset` -> epoch-ms
+ *   `number`; an unparseable trace-id epoch falls back to `0` (the epoch, the ordering analog of C#
+ *   `DateTimeOffset.MinValue`). `CancellationToken` -> optional `AbortSignal` (threaded to `send` as
+ *   `{ abortSignal }`); `Task.WhenAll` -> `Promise.all`; `StringComparer.Ordinal` -> an ordinal compare.
+ * - `addXRayFleetReadModel` constructs `new XRayClient({})` inside the `IMeshTraceSource` factory rather than
+ *   resolving a container-registered `IAmazonXRay` (there is no ambient AWS client token in the TS DI), the
+ *   same pattern as the `addSqs*` extensions.
+ * - Unlike the Tempo/Jaeger ports, `MeshTraceEvent.exceptionType` IS carried here: this port adds the
+ *   `exceptionType` field to `@benzenejs/mesh-wire`'s `MeshTraceEvent` (it was missing from the snapshot), and
+ *   the mapper reads `benzene.exception.type` into it (spec §3 "the failure's WHY").
+ */
+__exportStar(require("./XRayTraceSourceOptions"), exports);
+__exportStar(require("./XRaySegmentMapper"), exports);
+__exportStar(require("./XRayTraceSource"), exports);
+__exportStar(require("./Extensions"), exports);

package/package.json

@@ -1,6 +1,19 @@
 {
   "name": "@benzenejs/mesh-fleet-aws-xray",
-  "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.Fleet.Aws.XRay",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@aws-sdk/client-xray": "^3.700.0",
+    "@benzenejs/abstractions": "0.1.0-beta.2",
+    "@benzenejs/mesh-collector": "0.1.0-beta.2",
+    "@benzenejs/mesh-contracts": "0.1.0-beta.2",
+    "@benzenejs/mesh-wire": "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.