@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/workloads/stateless/cron.d.ts

@@ -0,0 +1,49 @@
+import { StatelessWorkload } from "../../workloads/stateless/stateless-workload.js";
+export interface CronOptions {
+    /**
+     * Function with the code that will be executed.
+     */
+    run: () => Promise<void>;
+    /**
+     * Schedule in crontab format.
+     */
+    schedule: string;
+}
+/**
+ * Workload for recurring tasks.
+ *
+ * A Cron workload is initialized with a unique id and the following options:
+ *
+ * - `schedule` in [unix-cron](https://man7.org/linux/man-pages/man5/crontab.5.html)
+ * format to specify when it should run.
+ *
+ * - `run` function with the code that will be executed.
+ *
+ * @example
+ * ```ts
+ * import { Cron } from "@monolayer/sdk";
+ *
+ * const reports = new Cron("reports", {
+ *   schedule: "* * * * *",
+ *   run: async () => {
+ *     // Do something;
+ *   },
+ * });
+ *
+ * export default reports;
+ * ```
+ */
+export declare class Cron extends StatelessWorkload {
+    /**
+     * Unique ID
+     */
+    id: string;
+    options: CronOptions;
+    run: () => Promise<void>;
+    schedule: string;
+    constructor(
+    /**
+     * Unique ID
+     */
+    id: string, options: CronOptions);
+}

package/dist/cjs/workloads/stateless/cron.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cron = void 0;
+const cron_parser_1 = __importDefault(require("cron-parser"));
+const stateless_workload_js_1 = require("../../workloads/stateless/stateless-workload.js");
+/**
+ * Workload for recurring tasks.
+ *
+ * A Cron workload is initialized with a unique id and the following options:
+ *
+ * - `schedule` in [unix-cron](https://man7.org/linux/man-pages/man5/crontab.5.html)
+ * format to specify when it should run.
+ *
+ * - `run` function with the code that will be executed.
+ *
+ * @example
+ * ```ts
+ * import { Cron } from "@monolayer/sdk";
+ *
+ * const reports = new Cron("reports", {
+ *   schedule: "* * * * *",
+ *   run: async () => {
+ *     // Do something;
+ *   },
+ * });
+ *
+ * export default reports;
+ * ```
+ */
+class Cron extends stateless_workload_js_1.StatelessWorkload {
+    constructor(
+    /**
+     * Unique ID
+     */
+    id, options) {
+        super(id);
+        this.id = id;
+        this.options = options;
+        this.run = options.run;
+        this.schedule = parseSchedule(options.schedule);
+    }
+}
+exports.Cron = Cron;
+function parseSchedule(schedule) {
+    try {
+        const parsed = cron_parser_1.default.parseExpression(schedule);
+        return parsed.stringify();
+    }
+    catch {
+        throw new Error(`Failed to parse schedule: ${schedule}`);
+    }
+}

package/dist/cjs/workloads/stateless/stateless-workload.d.ts

@@ -0,0 +1,3 @@
+import { Workload } from "../../workloads/workload.js";
+export declare class StatelessWorkload extends Workload {
+}

package/dist/cjs/workloads/stateless/stateless-workload.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatelessWorkload = void 0;
+const workload_js_1 = require("../../workloads/workload.js");
+class StatelessWorkload extends workload_js_1.Workload {
+}
+exports.StatelessWorkload = StatelessWorkload;

package/dist/cjs/workloads/stateless/task/backoffs.d.ts

@@ -0,0 +1,9 @@
+export interface ConstantBackoff {
+    type: "constant";
+    delay: number;
+}
+export interface ExponentialBackoff {
+    type: "exponential";
+    delay: number;
+}
+export declare function computeBackoff(attemptsMade: number, backoff?: ExponentialBackoff | ConstantBackoff): number;

package/dist/cjs/workloads/stateless/task/backoffs.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBackoff = computeBackoff;
+function computeBackoff(attemptsMade, backoff) {
+    if (backoff !== undefined) {
+        switch (backoff.type) {
+            case "constant":
+                return backoff.delay;
+            case "exponential":
+                if (backoff.delay < 0 || attemptsMade < 0) {
+                    throw new Error("Retry number cannot be less that 0");
+                }
+                return Math.round(Math.pow(2, attemptsMade) * backoff.delay);
+        }
+    }
+    return 0;
+}

package/dist/cjs/workloads/stateless/task/dispatcher.d.ts

@@ -0,0 +1,3 @@
+import { developmentDispatch } from "../../../workloads/stateless/task/local.js";
+export declare const dispatcherAdapterSymbol: unique symbol;
+export declare function dispatcher(): Promise<typeof developmentDispatch>;

package/dist/cjs/workloads/stateless/task/dispatcher.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatcherAdapterSymbol = void 0;
+exports.dispatcher = dispatcher;
+const local_js_1 = require("../../../workloads/stateless/task/local.js");
+exports.dispatcherAdapterSymbol = Symbol.for("@monolayer/sdk-task-dispacher");
+const TASK_DISPATCHER_SYMBOL = Symbol.for("@monolayer/sdk/task-dispatcher");
+async function dispatcher() {
+    if (process.env.NODE_ENV === "production") {
+        // @ts-expect-error defined at runtime
+        const dispatcher = globalThis[TASK_DISPATCHER_SYMBOL];
+        if (dispatcher === undefined)
+            throw new Error(`undefined dispatcher`);
+        return dispatcher;
+    }
+    else {
+        if (process.env.NODE_ENV === "test") {
+            return local_js_1.testDispatch;
+        }
+        return local_js_1.developmentDispatch;
+    }
+}

package/dist/cjs/workloads/stateless/task/local.d.ts

@@ -0,0 +1,14 @@
+import { type ExecutionId } from "../../../workloads/stateless/task/perform-now.js";
+import type { PerformOptions, Task } from "../../../workloads/stateless/task/task.js";
+export declare function developmentDispatch<P>(task: Task<P>, data: P | P[], options?: PerformOptions): Promise<ExecutionId | ExecutionId[]>;
+export declare function testDispatch<P>(task: Task<P>, data: P | P[], options?: PerformOptions): Promise<ExecutionId | ExecutionId[]>;
+export declare const testDispatchers: Record<string, {
+    executionId: ExecutionId;
+    data: unknown;
+}[]>;
+export declare function dispatcherForTask<P>(task: Task<P>): DispatcherTask<P>[];
+interface DispatcherTask<P> {
+    executionId: ExecutionId;
+    data: P;
+}
+export {};

package/dist/cjs/workloads/stateless/task/local.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDispatchers = void 0;
+exports.developmentDispatch = developmentDispatch;
+exports.testDispatch = testDispatch;
+exports.dispatcherForTask = dispatcherForTask;
+const remember_1 = require("@epic-web/remember");
+const crypto_1 = require("crypto");
+const perform_now_js_1 = require("../../../workloads/stateless/task/perform-now.js");
+async function developmentDispatch(task, data, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+options) {
+    if (Array.isArray(data)) {
+        const executionId = [];
+        for (const single of data) {
+            await (0, perform_now_js_1.performNow)(task, single);
+            executionId.push((0, crypto_1.randomUUID)());
+        }
+        return executionId;
+    }
+    await (0, perform_now_js_1.performNow)(task, data);
+    return (0, crypto_1.randomUUID)();
+}
+async function testDispatch(task, data, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+options) {
+    const testDispather = dispatcherForTask(task);
+    if (Array.isArray(data)) {
+        const executionIds = [];
+        const executionId = (0, crypto_1.randomUUID)();
+        for (const single of data) {
+            testDispather.push({
+                executionId,
+                data: single,
+            });
+            executionIds.push(executionId);
+        }
+        return executionIds;
+    }
+    const executionId = (0, crypto_1.randomUUID)();
+    testDispather.push({
+        executionId: executionId,
+        data: data,
+    });
+    return executionId;
+}
+exports.testDispatchers = (0, remember_1.remember)("TestDispatchers", () => ({}));
+function dispatcherForTask(task) {
+    const queueKey = task.id;
+    if (exports.testDispatchers[queueKey] === undefined) {
+        exports.testDispatchers[queueKey] = [];
+    }
+    return exports.testDispatchers[queueKey];
+}

package/dist/cjs/workloads/stateless/task/perform-later.d.ts

@@ -0,0 +1,2 @@
+import type { PerformOptions, Task } from "../../../workloads/stateless/task/task.js";
+export declare function performLater<P>(task: Task<P>, data: P | P[], options?: PerformOptions): Promise<import("./perform-now").ExecutionId | import("./perform-now").ExecutionId[]>;

package/dist/cjs/workloads/stateless/task/perform-later.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performLater = performLater;
+const dispatcher_js_1 = require("../../../workloads/stateless/task/dispatcher.js");
+async function performLater(task, data, options) {
+    return await (await (0, dispatcher_js_1.dispatcher)())(task, data, options);
+}

package/dist/cjs/workloads/stateless/task/perform-now.d.ts

@@ -0,0 +1,5 @@
+import type { Task } from "../../../workloads/stateless/task/task.js";
+export declare function performNow<P>(task: Task<P>, data: P | P[]): Promise<ExecutionId | ExecutionId[]>;
+export type ExecutionId = string & {
+    _brand: "ExecutionId";
+};

package/dist/cjs/workloads/stateless/task/perform-now.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performNow = performNow;
+const crypto_1 = require("crypto");
+const perform_js_1 = __importDefault(require("../../../workloads/stateless/task/perform.js"));
+async function performNow(task, data) {
+    if (!Array.isArray(data)) {
+        const taskId = (0, crypto_1.randomUUID)();
+        await (0, perform_js_1.default)({ task, taskId, data });
+        return taskId;
+    }
+    else {
+        const taskIds = [];
+        for (const singlePayload of data) {
+            const taskId = (0, crypto_1.randomUUID)();
+            await (0, perform_js_1.default)({ task, taskId, data: singlePayload });
+            taskIds.push(taskId);
+        }
+        return taskIds;
+    }
+}

package/dist/cjs/workloads/stateless/task/perform.d.ts

@@ -0,0 +1,7 @@
+import { type Task } from "../../../workloads/stateless/task/task.js";
+declare const _default: <P>({ task, taskId, data, }: {
+    task: Task<P>;
+    taskId: string;
+    data: P;
+}) => Promise<void>;
+export default _default;

package/dist/cjs/workloads/stateless/task/perform.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = async ({ task, taskId, data, }) => {
+    try {
+        await task.work({ taskId, data });
+    }
+    catch (error) {
+        task.handleError(error, data, taskId);
+    }
+};

package/dist/cjs/workloads/stateless/task/task.d.ts

@@ -0,0 +1,88 @@
+import type { ConstantBackoff, ExponentialBackoff } from "../../../workloads/stateless/task/backoffs.js";
+import { Workload } from "../../../workloads/workload.js";
+export declare class Task<P> extends Workload {
+    /**
+     * Name of the task.
+     */
+    name: string;
+    /**
+     * Function that processes a task.
+     */
+    work: (task: {
+        taskId: string;
+        data: P;
+    }) => Promise<void>;
+    options?: TaskOptions<P> | undefined;
+    constructor(
+    /**
+     * Name of the task.
+     */
+    name: string, 
+    /**
+     * Function that processes a task.
+     */
+    work: (task: {
+        taskId: string;
+        data: P;
+    }) => Promise<void>, options?: TaskOptions<P> | undefined);
+    /**
+     * Performs the task immediately in the current processs.
+     */
+    performNow(data: P | P[]): Promise<void>;
+    /**
+     * Performs the task later, dispatching the task to a queue.
+     *
+     * **NOTES**
+     *
+     * In development, the task will be performed immediately.
+     *
+     * In test, the task will collected ans can be retrieved with the `performedTasks` test helper.
+     */
+    performLater(data: P | P[], options?: PerformOptions): Promise<import("../../../workloads/stateless/task/perform-now.js").ExecutionId | import("../../../workloads/stateless/task/perform-now.js").ExecutionId[]>;
+    handleError(error?: unknown, data?: P, executionId?: string): void;
+}
+export interface TaskOptions<P> {
+    onError?: (error: TaskError<P>) => void;
+    retry?: RetryOptions;
+}
+export declare class TaskError<P> extends Error {
+    cause: TaskErrorCause<P>;
+    constructor(message: string, cause: TaskErrorCause<P>);
+}
+export type TaskErrorCause<P> = {
+    task: string;
+    executionId?: string;
+    data?: P;
+    error: unknown;
+};
+export interface RetryOptions {
+    /**
+     * The total number of attempts to try the job until it completes.
+     * @defaultValue 0
+     */
+    times: number;
+    /**
+     * Backoff setting for automatic retries if the job fails.
+     *
+     * **Important**
+     *
+     * This setting does not have any effect on Tasks backed by an `SQS` queue in production.
+     *
+     * Retries will happen after the `VisibilityTimeout` of the message expires (30 seconds by default).
+     * See: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html#consumer-fails-to-process-message
+     *
+     * You can to implement an custom backoff strategy using a dead-letter queue to handle retries
+     * and a Lambda function.
+     *
+     * @defaultValue { type: "constant", delay: 0 }
+     */
+    backoff?: ExponentialBackoff | ConstantBackoff;
+}
+export interface PerformOptions {
+    /**
+     * Amount in milliseconds to wait until this task can be processed.
+     *
+     * @defaultValue 0
+     */
+    delay?: number;
+}

package/dist/cjs/workloads/stateless/task/task.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskError = exports.Task = void 0;
+const case_anything_1 = require("case-anything");
+const perform_later_js_1 = require("../../../workloads/stateless/task/perform-later.js");
+const perform_now_js_1 = require("../../../workloads/stateless/task/perform-now.js");
+const workload_js_1 = require("../../../workloads/workload.js");
+class Task extends workload_js_1.Workload {
+    constructor(
+    /**
+     * Name of the task.
+     */
+    name, 
+    /**
+     * Function that processes a task.
+     */
+    work, options) {
+        super((0, case_anything_1.kebabCase)(name));
+        this.name = name;
+        this.work = work;
+        this.options = options;
+    }
+    /**
+     * Performs the task immediately in the current processs.
+     */
+    async performNow(data) {
+        await (0, perform_now_js_1.performNow)(this, data);
+    }
+    /**
+     * Performs the task later, dispatching the task to a queue.
+     *
+     * **NOTES**
+     *
+     * In development, the task will be performed immediately.
+     *
+     * In test, the task will collected ans can be retrieved with the `performedTasks` test helper.
+     */
+    async performLater(data, options) {
+        return await (0, perform_later_js_1.performLater)(this, data, options);
+    }
+    handleError(error, data, executionId) {
+        if (this.options?.onError) {
+            this.options?.onError(new TaskError("Error while performing tasks", {
+                task: this.id,
+                executionId,
+                data,
+                error,
+            }));
+        }
+        else {
+            console.log(`An error was thrown in ${this.id} and the onError callback function is undefined.`);
+        }
+    }
+}
+exports.Task = Task;
+class TaskError extends Error {
+    constructor(message, cause) {
+        super(message, { cause });
+    }
+}
+exports.TaskError = TaskError;

package/dist/cjs/workloads/stateless/task/validate-data-size.d.ts

@@ -0,0 +1 @@
+export declare function validateJsonStringified<P>(data: P, max?: number): void;

package/dist/cjs/workloads/stateless/task/validate-data-size.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJsonStringified = validateJsonStringified;
+function validateJsonStringified(data, max = 256000) {
+    const dataString = JSON.stringify(typeof data === "undefined" ? {} : data);
+    const byteLength = Buffer.byteLength(dataString, "utf8");
+    if (byteLength > max) {
+        throw new Error(`Data size exceeds the limit (${max} bytes)`);
+    }
+}

package/dist/cjs/workloads/workload.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @group Abstract Classes
+ */
+export declare abstract class Workload {
+    /**
+     * Unique ID
+     */
+    readonly id: string;
+    constructor(
+    /**
+     * Unique ID.
+     */
+    id: string);
+}

package/dist/cjs/workloads/workload.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workload = void 0;
+/**
+ * @group Abstract Classes
+ */
+class Workload {
+    constructor(
+    /**
+     * Unique ID.
+     */
+    id) {
+        this.id = id;
+    }
+}
+exports.Workload = Workload;

package/dist/cjs/workloads.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module main
+ */
+export { ContainerConfig, type Configuration, } from "./configuration.js";
+export { AfterRollout } from "./workloads/app-lifecycle/after-rollout.js";
+export { BeforeRollout } from "./workloads/app-lifecycle/before-rollout.js";
+export { Bootstrap } from "./workloads/app-lifecycle/bootstrap.js";
+export { type LifecycleWorkload } from "./workloads/app-lifecycle/lifecycle-workload.js";
+export { Bucket, BucketOptions, bucketLocalConfiguration, type AccessGrant, type PublicAccess, } from "./workloads/stateful/bucket.js";
+export type { Database } from "./workloads/stateful/database.js";
+export { PostgresDatabase } from "./workloads/stateful/postgres-database.js";
+export { Redis } from "./workloads/stateful/redis.js";
+export type { StatefulWorkload, StatefulWorkloadWithClient, } from "./workloads/stateful/stateful-workload.js";
+export { ChannelData } from "./workloads/stateless/broadcast/channel-data.js";
+export { broadcastClient } from "./workloads/stateless/broadcast/client/client.js";
+export { Broadcast } from "./workloads/stateless/broadcast/router.js";
+export type { StatelessWorkload } from "./workloads/stateless/stateless-workload.js";
+export { Task, type RetryOptions, type TaskOptions, } from "./workloads/stateless/task/task.js";
+export type { Workload } from "./workloads/workload.js";
+export { Cron, type CronOptions } from "./workloads/stateless/cron.js";
+export { BroadcastPublisher } from "./workloads/stateless/broadcast/client/app-sync-publisher.js";
+export { Broadcast as BroadcastProvider } from "./workloads/stateless/broadcast/client/provider.js";

package/dist/cjs/workloads.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastProvider = exports.BroadcastPublisher = exports.Cron = exports.Task = exports.Broadcast = exports.broadcastClient = exports.ChannelData = exports.Redis = exports.PostgresDatabase = exports.bucketLocalConfiguration = exports.Bucket = exports.Bootstrap = exports.BeforeRollout = exports.AfterRollout = void 0;
+var after_rollout_js_1 = require("./workloads/app-lifecycle/after-rollout.js");
+Object.defineProperty(exports, "AfterRollout", { enumerable: true, get: function () { return after_rollout_js_1.AfterRollout; } });
+var before_rollout_js_1 = require("./workloads/app-lifecycle/before-rollout.js");
+Object.defineProperty(exports, "BeforeRollout", { enumerable: true, get: function () { return before_rollout_js_1.BeforeRollout; } });
+var bootstrap_js_1 = require("./workloads/app-lifecycle/bootstrap.js");
+Object.defineProperty(exports, "Bootstrap", { enumerable: true, get: function () { return bootstrap_js_1.Bootstrap; } });
+var bucket_js_1 = require("./workloads/stateful/bucket.js");
+Object.defineProperty(exports, "Bucket", { enumerable: true, get: function () { return bucket_js_1.Bucket; } });
+Object.defineProperty(exports, "bucketLocalConfiguration", { enumerable: true, get: function () { return bucket_js_1.bucketLocalConfiguration; } });
+var postgres_database_js_1 = require("./workloads/stateful/postgres-database.js");
+Object.defineProperty(exports, "PostgresDatabase", { enumerable: true, get: function () { return postgres_database_js_1.PostgresDatabase; } });
+var redis_js_1 = require("./workloads/stateful/redis.js");
+Object.defineProperty(exports, "Redis", { enumerable: true, get: function () { return redis_js_1.Redis; } });
+var channel_data_js_1 = require("./workloads/stateless/broadcast/channel-data.js");
+Object.defineProperty(exports, "ChannelData", { enumerable: true, get: function () { return channel_data_js_1.ChannelData; } });
+var client_js_1 = require("./workloads/stateless/broadcast/client/client.js");
+Object.defineProperty(exports, "broadcastClient", { enumerable: true, get: function () { return client_js_1.broadcastClient; } });
+var router_js_1 = require("./workloads/stateless/broadcast/router.js");
+Object.defineProperty(exports, "Broadcast", { enumerable: true, get: function () { return router_js_1.Broadcast; } });
+var task_js_1 = require("./workloads/stateless/task/task.js");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return task_js_1.Task; } });
+var cron_js_1 = require("./workloads/stateless/cron.js");
+Object.defineProperty(exports, "Cron", { enumerable: true, get: function () { return cron_js_1.Cron; } });
+var app_sync_publisher_js_1 = require("./workloads/stateless/broadcast/client/app-sync-publisher.js");
+Object.defineProperty(exports, "BroadcastPublisher", { enumerable: true, get: function () { return app_sync_publisher_js_1.BroadcastPublisher; } });
+var provider_js_1 = require("./workloads/stateless/broadcast/client/provider.js");
+Object.defineProperty(exports, "BroadcastProvider", { enumerable: true, get: function () { return provider_js_1.Broadcast; } });

package/dist/esm/configuration.d.ts

@@ -0,0 +1,65 @@
+export interface Configuration {
+    /**
+     * Path to a folder with workloads.
+     *
+     */
+    workloadsPath: string;
+    /**
+     * Container configurations.
+     */
+    containers?: {
+        /**
+         * @default { imageName: "postgres:16.5-alpine3.20", exposedPorts: [ { container: 5432, host: 5432 } ] }
+         */
+        postgresDatabase?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "redis:7.4.1-alpine3.20", exposedPorts: [ { container: 6379, host: 6379 } ] }
+         */
+        redis?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "mysql:8.4.3", exposedPorts: [ { container: 3306, host: 3306 } ] }
+         */
+        mySqlDatabase?: ContainerConfig;
+        /**
+         * @default
+         * { imageName: "localstack/localstack:3.8.1", exposedPorts: [ { container: 4566, host: 4566 } ] }
+         */
+        minio?: ContainerConfig;
+    };
+    /**
+     * Names of the dotenv files to write the workloads' connection strings.
+     */
+    envFileName?: {
+        /**
+         * File name for development.
+         *
+         * @default
+         * .env.local
+         */
+        development?: string;
+        /**
+         * File name for test.
+         *
+         * @default
+         * .env.test.local
+         */
+        test?: string;
+    };
+}
+export interface ContainerConfig {
+    /**
+     * Docker image name.
+     */
+    imageName?: string;
+    /**
+     * Host port to publish the exposed container port.
+     */
+    exposedPorts?: {
+        container: number;
+        host: number;
+    }[];
+}
+export declare const workloadsConfiguration: () => Promise<Configuration>;
+export declare const packageName: any;

package/dist/esm/configuration.js

@@ -0,0 +1,15 @@
+import { remember } from "@epic-web/remember";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { cwd } from "node:process";
+async function importConfig() {
+    const imported = await import(path.join(cwd(), "monolayer.config.ts"));
+    return imported.default && imported.default.default
+        ? imported.default.default
+        : imported.default;
+}
+export const workloadsConfiguration = () => remember("workloadsConfiguration", async () => await importConfig());
+export const packageName = remember("packageName", () => {
+    const packageJSON = JSON.parse(readFileSync("package.json").toString());
+    return packageJSON.name;
+});

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./configuration.js";
+export * from "./introspection.js";
+export * from "./test-helpers.js";
+export * from "./workloads.js";

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./configuration.js";
+export * from "./introspection.js";
+export * from "./test-helpers.js";
+export * from "./workloads.js";