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

package/dist/MeshAnnotationPublisher.d.ts

@@ -0,0 +1,36 @@
+import { MeshAnnotationThread } from '@benzenejs/mesh-contracts';
+import { IMeshArtifactStore } from './IMeshArtifactStore';
+/**
+ * Appends discussion notes to the `annotations.json` artifact - the write half of the mesh discussion
+ * feature. The read half is the artifact itself: it lives in the same `IMeshArtifactStore` as
+ * `manifest.json`, so any static host serves recorded discussion with zero backend, and only posting a new
+ * note needs this publisher's handler (`MeshAnnotationsMessageHandler`) running somewhere.
+ *
+ * Read-modify-write of the log is serialized per process with an async mutex (C#'s `SemaphoreSlim(1, 1)`
+ * -> a promise-chain lock; the single-threaded event loop still interleaves `await`s, so the lock is
+ * genuinely needed to stop two concurrent `addAsync` calls racing the read-modify-write). Concurrent
+ * writers in separate hosts are out of scope. An unparseable existing log starts fresh rather than failing
+ * - but never silently: the previous content is preserved to a timestamped sibling artifact first.
+ * `Guid.NewGuid().ToString("n")` -> `randomUUID()` with dashes stripped; `DateTimeOffset` -> epoch ms.
+ */
+export declare class MeshAnnotationPublisher {
+    private readonly store;
+    private readonly clock;
+    private readonly ids;
+    private writeLock;
+    /**
+     * @param store The artifact store the log lives in - the same one the aggregator publishes to.
+     * @param clock Supplies the current time (epoch ms); defaults to `Date.now`. Overridable for deterministic tests.
+     * @param ids Supplies new annotation ids; defaults to a dashless UUID. Overridable for deterministic tests.
+     */
+    constructor(store: IMeshArtifactStore, clock?: () => number, ids?: () => string);
+    /**
+     * Appends one note to the log and republishes `annotations.json`, returning the annotated entity's full
+     * thread (oldest first) so a caller can render the discussion it just posted into. Inputs are assumed
+     * already validated (the handler's job).
+     */
+    addAsync(entity: string, author: string, text: string): Promise<MeshAnnotationThread>;
+    /** Serializes read-modify-write against concurrent `addAsync` calls (the `SemaphoreSlim` port). */
+    private withLock;
+    private readLogAsync;
+}

package/dist/MeshAnnotationPublisher.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshAnnotationPublisher = void 0;
+/** Port of Benzene.Mesh.Aggregator.MeshAnnotationPublisher. */
+const node_crypto_1 = require("node:crypto");
+const mesh_contracts_1 = require("@benzenejs/mesh-contracts");
+const ArtifactPath = 'annotations.json';
+/**
+ * Appends discussion notes to the `annotations.json` artifact - the write half of the mesh discussion
+ * feature. The read half is the artifact itself: it lives in the same `IMeshArtifactStore` as
+ * `manifest.json`, so any static host serves recorded discussion with zero backend, and only posting a new
+ * note needs this publisher's handler (`MeshAnnotationsMessageHandler`) running somewhere.
+ *
+ * Read-modify-write of the log is serialized per process with an async mutex (C#'s `SemaphoreSlim(1, 1)`
+ * -> a promise-chain lock; the single-threaded event loop still interleaves `await`s, so the lock is
+ * genuinely needed to stop two concurrent `addAsync` calls racing the read-modify-write). Concurrent
+ * writers in separate hosts are out of scope. An unparseable existing log starts fresh rather than failing
+ * - but never silently: the previous content is preserved to a timestamped sibling artifact first.
+ * `Guid.NewGuid().ToString("n")` -> `randomUUID()` with dashes stripped; `DateTimeOffset` -> epoch ms.
+ */
+class MeshAnnotationPublisher {
+    store;
+    clock;
+    ids;
+    writeLock = Promise.resolve();
+    /**
+     * @param store The artifact store the log lives in - the same one the aggregator publishes to.
+     * @param clock Supplies the current time (epoch ms); defaults to `Date.now`. Overridable for deterministic tests.
+     * @param ids Supplies new annotation ids; defaults to a dashless UUID. Overridable for deterministic tests.
+     */
+    constructor(store, clock, ids) {
+        this.store = store;
+        this.clock = clock ?? (() => Date.now());
+        this.ids = ids ?? (() => (0, node_crypto_1.randomUUID)().replace(/-/g, ''));
+    }
+    /**
+     * Appends one note to the log and republishes `annotations.json`, returning the annotated entity's full
+     * thread (oldest first) so a caller can render the discussion it just posted into. Inputs are assumed
+     * already validated (the handler's job).
+     */
+    async addAsync(entity, author, text) {
+        return this.withLock(async () => {
+            const existing = await this.readLogAsync();
+            const annotation = new mesh_contracts_1.MeshAnnotation(this.ids(), entity, author, text, this.clock());
+            const annotations = [...existing, annotation];
+            await this.store.publishAsync(ArtifactPath, JSON.stringify(new mesh_contracts_1.MeshAnnotationLog(this.clock(), annotations), null, 2));
+            return new mesh_contracts_1.MeshAnnotationThread(entity, annotations.filter((a) => a.entity === entity).sort((a, b) => a.createdAtUtc - b.createdAtUtc));
+        });
+    }
+    /** Serializes read-modify-write against concurrent `addAsync` calls (the `SemaphoreSlim` port). */
+    withLock(action) {
+        const run = this.writeLock.then(action, action);
+        // Keep the chain alive but swallow errors so one failed write doesn't poison the lock for the next.
+        this.writeLock = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async readLogAsync() {
+        let json;
+        try {
+            json = await this.store.tryReadAsync(ArtifactPath);
+            if (json === undefined) {
+                return [];
+            }
+            const log = JSON.parse(json);
+            return log?.annotations ?? [];
+        }
+        catch {
+            // A corrupt log must not brick discussion forever - but user-authored notes are the one artifact
+            // that can't be regenerated from the fleet, so park the unreadable content aside (best-effort)
+            // instead of overwriting it.
+            if (json !== undefined) {
+                try {
+                    await this.store.publishAsync(`annotations.unreadable-${Math.floor(this.clock() / 1000)}.json`, json);
+                }
+                catch {
+                    // Preserving the corrupt log is best-effort only.
+                }
+            }
+            return [];
+        }
+    }
+}
+exports.MeshAnnotationPublisher = MeshAnnotationPublisher;

package/dist/MeshAnnotationsMessageHandler.d.ts

@@ -0,0 +1,26 @@
+/** Port of Benzene.Mesh.Aggregator.MeshAnnotationsMessageHandler. */
+import { IBenzeneResultOf } from '@benzenejs/abstractions';
+import { IMessageHandler } from '@benzenejs/abstractions-message-handlers';
+import { MeshAnnotationRequest, MeshAnnotationThread } from '@benzenejs/mesh-contracts';
+import { MeshAnnotationPublisher } from './MeshAnnotationPublisher';
+/**
+ * The discussion write endpoint - attaches one note to one entity of the estate and returns that entity's
+ * full thread. Reachable on whatever transport the host already runs, the same dogfooded shape as
+ * `MeshReportMessageHandler`.
+ *
+ * Identity is deliberately out of scope: `MeshAnnotationRequest.author` is a self-declared display name, and
+ * authenticating who may post is the fronting gateway's job. The handler enforces only shape: required
+ * fields and size bounds, so one post can't bloat the artifact every reader downloads. `const` fields ->
+ * `static readonly`.
+ */
+export declare class MeshAnnotationsMessageHandler implements IMessageHandler<MeshAnnotationRequest, MeshAnnotationThread> {
+    private readonly publisher;
+    /** Maximum accepted length of `MeshAnnotationRequest.entity`. */
+    static readonly MaxEntityLength = 200;
+    /** Maximum accepted length of `MeshAnnotationRequest.author`. */
+    static readonly MaxAuthorLength = 80;
+    /** Maximum accepted length of `MeshAnnotationRequest.text`. */
+    static readonly MaxTextLength = 4000;
+    constructor(publisher: MeshAnnotationPublisher);
+    handleAsync(request: MeshAnnotationRequest): Promise<IBenzeneResultOf<MeshAnnotationThread>>;
+}

package/dist/MeshAnnotationsMessageHandler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshAnnotationsMessageHandler = void 0;
+const results_1 = require("@benzenejs/results");
+/**
+ * The discussion write endpoint - attaches one note to one entity of the estate and returns that entity's
+ * full thread. Reachable on whatever transport the host already runs, the same dogfooded shape as
+ * `MeshReportMessageHandler`.
+ *
+ * Identity is deliberately out of scope: `MeshAnnotationRequest.author` is a self-declared display name, and
+ * authenticating who may post is the fronting gateway's job. The handler enforces only shape: required
+ * fields and size bounds, so one post can't bloat the artifact every reader downloads. `const` fields ->
+ * `static readonly`.
+ */
+class MeshAnnotationsMessageHandler {
+    publisher;
+    /** Maximum accepted length of `MeshAnnotationRequest.entity`. */
+    static MaxEntityLength = 200;
+    /** Maximum accepted length of `MeshAnnotationRequest.author`. */
+    static MaxAuthorLength = 80;
+    /** Maximum accepted length of `MeshAnnotationRequest.text`. */
+    static MaxTextLength = 4000;
+    constructor(publisher) {
+        this.publisher = publisher;
+    }
+    async handleAsync(request) {
+        const entity = request?.entity?.trim();
+        const author = request?.author?.trim();
+        const text = request?.text?.trim();
+        if (entity === undefined || entity.length === 0) {
+            return results_1.BenzeneResult.badRequest('entity is required');
+        }
+        if (author === undefined || author.length === 0) {
+            return results_1.BenzeneResult.badRequest('author is required');
+        }
+        if (text === undefined || text.length === 0) {
+            return results_1.BenzeneResult.badRequest('text is required');
+        }
+        if (entity.length > MeshAnnotationsMessageHandler.MaxEntityLength ||
+            author.length > MeshAnnotationsMessageHandler.MaxAuthorLength ||
+            text.length > MeshAnnotationsMessageHandler.MaxTextLength) {
+            return results_1.BenzeneResult.badRequest(`bounds exceeded: entity <= ${MeshAnnotationsMessageHandler.MaxEntityLength}, ` +
+                `author <= ${MeshAnnotationsMessageHandler.MaxAuthorLength}, ` +
+                `text <= ${MeshAnnotationsMessageHandler.MaxTextLength} characters`);
+        }
+        const thread = await this.publisher.addAsync(entity, author, text);
+        return results_1.BenzeneResult.created(thread);
+    }
+}
+exports.MeshAnnotationsMessageHandler = MeshAnnotationsMessageHandler;

package/dist/MeshReportMessageHandler.d.ts

@@ -0,0 +1,15 @@
+/** Port of Benzene.Mesh.Aggregator.MeshReportMessageHandler. */
+import { IMessageHandlerNoResponse } from '@benzenejs/abstractions-message-handlers';
+import { IMeshReportPublisher, MeshServiceReport } from '@benzenejs/mesh-contracts';
+/**
+ * The push/self-report ingestion endpoint - accepts a `MeshServiceReport` and hands it to whichever
+ * `IMeshReportPublisher` is registered (`ArtifactStoreMeshReportPublisher` by default, via
+ * `addMeshAggregator`). Reachable on whatever transport the host already runs, the same dogfooded shape as
+ * `MeshAggregateMessageHandler`. `IMessageHandler<MeshServiceReport>` (no response) ->
+ * `IMessageHandlerNoResponse<MeshServiceReport>`.
+ */
+export declare class MeshReportMessageHandler implements IMessageHandlerNoResponse<MeshServiceReport> {
+    private readonly publisher;
+    constructor(publisher: IMeshReportPublisher);
+    handleAsync(request: MeshServiceReport): Promise<void>;
+}

package/dist/MeshReportMessageHandler.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshReportMessageHandler = void 0;
+/**
+ * The push/self-report ingestion endpoint - accepts a `MeshServiceReport` and hands it to whichever
+ * `IMeshReportPublisher` is registered (`ArtifactStoreMeshReportPublisher` by default, via
+ * `addMeshAggregator`). Reachable on whatever transport the host already runs, the same dogfooded shape as
+ * `MeshAggregateMessageHandler`. `IMessageHandler<MeshServiceReport>` (no response) ->
+ * `IMessageHandlerNoResponse<MeshServiceReport>`.
+ */
+class MeshReportMessageHandler {
+    publisher;
+    constructor(publisher) {
+        this.publisher = publisher;
+    }
+    handleAsync(request) {
+        return this.publisher.publishAsync(request);
+    }
+}
+exports.MeshReportMessageHandler = MeshReportMessageHandler;

package/dist/MeshSnapshotBuilder.d.ts

@@ -0,0 +1,24 @@
+/** Port of Benzene.Mesh.Aggregator.MeshSnapshotBuilder. */
+import { HealthCheckResponse } from '@benzenejs/health-checks-core';
+import { MeshServiceSnapshot } from '@benzenejs/mesh-contracts';
+import { IMeshArtifactStore } from './IMeshArtifactStore';
+/**
+ * Builds a `MeshServiceSnapshot` from a spec/health fetch (or self-reported push), reading the spec's hash
+ * and comparing it against the previous run's via `IMeshArtifactStore`. The hash is the **served**
+ * `contractHash` of the service's Contract Document (contract-document.md §6.1) — the aggregator computes no
+ * hash of its own, so its drift flag means exactly what a generated client's drift check means. A spec
+ * without one (not a Contract Document, or none fetched) has no hash, and so no drift verdict. Shared by `MeshAggregator` (pulled
+ * snapshots) and any `IMeshReportPublisher` that turns a pushed `MeshServiceReport` into the same snapshot
+ * shape, so both compute `MeshServiceSnapshot.contractDrift` identically instead of two copies of the logic.
+ *
+ * The internal C# `static class` becomes a namespace of free functions (the port's "static class -> free
+ * functions" rule). Reading back the previous snapshot deserializes only the `specHash` field: `JSON.parse`
+ * yields a plain object with that camelCase field, so no class reconstruction is needed.
+ */
+export declare const MeshSnapshotBuilder: {
+    /**
+     * Builds a snapshot, reading the previous run's spec hash from `store` for drift comparison.
+     * @param error The exception type name from a failed fetch, or `undefined`.
+     */
+    buildAsync(store: IMeshArtifactStore, name: string, fetchedAtUtc: number, specJson: string | undefined, health: HealthCheckResponse | undefined, error: string | undefined): Promise<MeshServiceSnapshot>;
+};

package/dist/MeshSnapshotBuilder.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshSnapshotBuilder = void 0;
+const mesh_contracts_1 = require("@benzenejs/mesh-contracts");
+/**
+ * Builds a `MeshServiceSnapshot` from a spec/health fetch (or self-reported push), reading the spec's hash
+ * and comparing it against the previous run's via `IMeshArtifactStore`. The hash is the **served**
+ * `contractHash` of the service's Contract Document (contract-document.md §6.1) — the aggregator computes no
+ * hash of its own, so its drift flag means exactly what a generated client's drift check means. A spec
+ * without one (not a Contract Document, or none fetched) has no hash, and so no drift verdict. Shared by `MeshAggregator` (pulled
+ * snapshots) and any `IMeshReportPublisher` that turns a pushed `MeshServiceReport` into the same snapshot
+ * shape, so both compute `MeshServiceSnapshot.contractDrift` identically instead of two copies of the logic.
+ *
+ * The internal C# `static class` becomes a namespace of free functions (the port's "static class -> free
+ * functions" rule). Reading back the previous snapshot deserializes only the `specHash` field: `JSON.parse`
+ * yields a plain object with that camelCase field, so no class reconstruction is needed.
+ */
+exports.MeshSnapshotBuilder = {
+    /**
+     * Builds a snapshot, reading the previous run's spec hash from `store` for drift comparison.
+     * @param error The exception type name from a failed fetch, or `undefined`.
+     */
+    async buildAsync(store, name, fetchedAtUtc, specJson, health, error) {
+        const specHash = servedContractHash(specJson);
+        const previousSpecHash = await tryGetPreviousSpecHashAsync(store, name);
+        const contractDrift = specHash !== undefined && previousSpecHash !== undefined && previousSpecHash !== specHash;
+        return new mesh_contracts_1.MeshServiceSnapshot(name, fetchedAtUtc, specJson, specHash, previousSpecHash, contractDrift, health, error);
+    },
+};
+/** The served `contractHash` of a fetched spec, or `undefined` when there is none. */
+function servedContractHash(specJson) {
+    if (specJson === undefined) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(specJson);
+        return typeof parsed?.contractHash === 'string' ? parsed.contractHash : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function tryGetPreviousSpecHashAsync(store, serviceName) {
+    const previousJson = await store.tryReadAsync(`services/${serviceName}.json`);
+    if (previousJson === undefined) {
+        return undefined;
+    }
+    try {
+        const previous = JSON.parse(previousJson);
+        return previous?.specHash ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/UnknownMeshServiceSource.d.ts

@@ -0,0 +1,17 @@
+/** Port of Benzene.Mesh.Aggregator.UnknownMeshServiceSource. */
+import { MeshServiceRegistryEntry } from '@benzenejs/mesh-contracts';
+import { IMeshServiceSource } from './IMeshServiceSource';
+/**
+ * Stand-in `IMeshServiceSource` returned when a `MeshServiceRegistryEntry.source` has no matching
+ * registered source - throws from both fetch methods so a misconfigured single entry surfaces as that
+ * service's own `unreachable`/error result (via the same try/catch every other fetch failure goes through
+ * in `MeshAggregator`), rather than crashing the whole aggregation run.
+ */
+export declare class UnknownMeshServiceSource implements IMeshServiceSource {
+    private readonly requestedSource;
+    readonly key: string;
+    constructor(requestedSource: string);
+    fetchSpecAsync(_entry: MeshServiceRegistryEntry, _cancellationToken?: AbortSignal): Promise<string>;
+    fetchHealthAsync(_entry: MeshServiceRegistryEntry, _cancellationToken?: AbortSignal): Promise<string>;
+    private notRegistered;
+}

package/dist/UnknownMeshServiceSource.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownMeshServiceSource = void 0;
+/**
+ * Stand-in `IMeshServiceSource` returned when a `MeshServiceRegistryEntry.source` has no matching
+ * registered source - throws from both fetch methods so a misconfigured single entry surfaces as that
+ * service's own `unreachable`/error result (via the same try/catch every other fetch failure goes through
+ * in `MeshAggregator`), rather than crashing the whole aggregation run.
+ */
+class UnknownMeshServiceSource {
+    requestedSource;
+    key;
+    constructor(requestedSource) {
+        this.requestedSource = requestedSource;
+        this.key = requestedSource;
+    }
+    fetchSpecAsync(_entry, _cancellationToken) {
+        throw this.notRegistered();
+    }
+    fetchHealthAsync(_entry, _cancellationToken) {
+        throw this.notRegistered();
+    }
+    notRegistered() {
+        return new Error(`No IMeshServiceSource registered for source "${this.requestedSource}".`);
+    }
+}
+exports.UnknownMeshServiceSource = UnknownMeshServiceSource;

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Port of Benzene.Mesh.Aggregator - the polling mesh aggregator: `MeshAggregator` fetches every registered
+ * service's spec/health (via an `IMeshServiceSource`), computes contract-drift and a cross-service topic
+ * catalog/topology/composite-AsyncAPI, and publishes the artifacts to an `IMeshArtifactStore`
+ * (`FileSystemMeshArtifactStore` ships). Also the push path (`ArtifactStoreMeshReportPublisher` +
+ * `MeshReportMessageHandler`), the discussion write path (`MeshAnnotationPublisher` +
+ * `MeshAnnotationsMessageHandler`), and `addMeshAggregator` wiring.
+ */
+export * from './IMeshArtifactStore';
+export * from './IMeshServiceSource';
+export * from './UnknownMeshServiceSource';
+export * from './FileSystemMeshArtifactStore';
+export * from './HttpMeshServiceSource';
+export * from './MeshSnapshotBuilder';
+export * from './ArtifactStoreMeshReportPublisher';
+export * from './MeshAnnotationPublisher';
+export * from './AsyncApiCompositor';
+export * from './MeshAggregator';
+export * from './MeshAggregateMessageHandler';
+export * from './MeshReportMessageHandler';
+export * from './MeshAnnotationsMessageHandler';
+export * from './Extensions';

package/dist/index.js

@@ -0,0 +1,38 @@
+"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.Aggregator - the polling mesh aggregator: `MeshAggregator` fetches every registered
+ * service's spec/health (via an `IMeshServiceSource`), computes contract-drift and a cross-service topic
+ * catalog/topology/composite-AsyncAPI, and publishes the artifacts to an `IMeshArtifactStore`
+ * (`FileSystemMeshArtifactStore` ships). Also the push path (`ArtifactStoreMeshReportPublisher` +
+ * `MeshReportMessageHandler`), the discussion write path (`MeshAnnotationPublisher` +
+ * `MeshAnnotationsMessageHandler`), and `addMeshAggregator` wiring.
+ */
+__exportStar(require("./IMeshArtifactStore"), exports);
+__exportStar(require("./IMeshServiceSource"), exports);
+__exportStar(require("./UnknownMeshServiceSource"), exports);
+__exportStar(require("./FileSystemMeshArtifactStore"), exports);
+__exportStar(require("./HttpMeshServiceSource"), exports);
+__exportStar(require("./MeshSnapshotBuilder"), exports);
+__exportStar(require("./ArtifactStoreMeshReportPublisher"), exports);
+__exportStar(require("./MeshAnnotationPublisher"), exports);
+__exportStar(require("./AsyncApiCompositor"), exports);
+__exportStar(require("./MeshAggregator"), exports);
+__exportStar(require("./MeshAggregateMessageHandler"), exports);
+__exportStar(require("./MeshReportMessageHandler"), exports);
+__exportStar(require("./MeshAnnotationsMessageHandler"), exports);
+__exportStar(require("./Extensions"), exports);

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@benzenejs/mesh-aggregator",
-  "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.Aggregator",
+  "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/core-message-handlers": "0.1.0-beta.2",
+    "@benzenejs/health-checks-core": "0.1.0-beta.2",
+    "@benzenejs/http": "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.